.config/coc/extensions/node_modules/coc-pyright/node_modules/pyright/dist/typeshed-fallback/stdlib/xml/etree/ElementTree.pyi

   1 import sys
   2 from _typeshed import FileDescriptor, StrOrBytesPath, SupportsWrite
   3 from typing import (
   4     IO,
   5     Any,
   6     Callable,
   7     Dict,
   8     Generator,
   9     ItemsView,
  10     Iterable,
  11     Iterator,
  12     KeysView,
  13     MutableSequence,
  14     Sequence,
  15     TypeVar,
  16     Union,
  17     overload,
  18 )
  19 from typing_extensions import Literal
  20
  21 _T = TypeVar("_T")
  22 _File = Union[StrOrBytesPath, FileDescriptor, IO[Any]]
  23
  24 VERSION: str
  25
  26 class ParseError(SyntaxError):
  27     code: int
  28     position: tuple[int, int]
  29
  30 def iselement(element: object) -> bool: ...
  31
  32 if sys.version_info >= (3, 8):
  33     @overload
  34     def canonicalize(
  35         xml_data: str | bytes | None = ...,
  36         *,
  37         out: None = ...,
  38         from_file: _File | None = ...,
  39         with_comments: bool = ...,
  40         strip_text: bool = ...,
  41         rewrite_prefixes: bool = ...,
  42         qname_aware_tags: Iterable[str] | None = ...,
  43         qname_aware_attrs: Iterable[str] | None = ...,
  44         exclude_attrs: Iterable[str] | None = ...,
  45         exclude_tags: Iterable[str] | None = ...,
  46     ) -> str: ...
  47     @overload
  48     def canonicalize(
  49         xml_data: str | bytes | None = ...,
  50         *,
  51         out: SupportsWrite[str],
  52         from_file: _File | None = ...,
  53         with_comments: bool = ...,
  54         strip_text: bool = ...,
  55         rewrite_prefixes: bool = ...,
  56         qname_aware_tags: Iterable[str] | None = ...,
  57         qname_aware_attrs: Iterable[str] | None = ...,
  58         exclude_attrs: Iterable[str] | None = ...,
  59         exclude_tags: Iterable[str] | None = ...,
  60     ) -> None: ...
  61
  62 class Element(MutableSequence[Element]):
  63     tag: str
  64     attrib: dict[str, str]
  65     text: str | None
  66     tail: str | None
  67     def __init__(self, tag: str | Callable[..., Element], attrib: dict[str, str] = ..., **extra: str) -> None: ...
  68     def append(self, __subelement: Element) -> None: ...
  69     def clear(self) -> None: ...
  70     def extend(self, __elements: Iterable[Element]) -> None: ...
  71     def find(self, path: str, namespaces: dict[str, str] | None = ...) -> Element | None: ...
  72     def findall(self, path: str, namespaces: dict[str, str] | None = ...) -> list[Element]: ...
  73     @overload
  74     def findtext(self, path: str, default: None = ..., namespaces: dict[str, str] | None = ...) -> str | None: ...
  75     @overload
  76     def findtext(self, path: str, default: _T, namespaces: dict[str, str] | None = ...) -> _T | str: ...
  77     @overload
  78     def get(self, key: str, default: None = ...) -> str | None: ...
  79     @overload
  80     def get(self, key: str, default: _T) -> str | _T: ...
  81     def insert(self, __index: int, __subelement: Element) -> None: ...
  82     def items(self) -> ItemsView[str, str]: ...
  83     def iter(self, tag: str | None = ...) -> Generator[Element, None, None]: ...
  84     def iterfind(self, path: str, namespaces: dict[str, str] | None = ...) -> Generator[Element, None, None]: ...
  85     def itertext(self) -> Generator[str, None, None]: ...
  86     def keys(self) -> KeysView[str]: ...
  87     def makeelement(self, __tag: str, __attrib: dict[str, str]) -> Element: ...
  88     def remove(self, __subelement: Element) -> None: ...
  89     def set(self, __key: str, __value: str) -> None: ...
  90     def __delitem__(self, i: int | slice) -> None: ...
  91     @overload
  92     def __getitem__(self, i: int) -> Element: ...
  93     @overload
  94     def __getitem__(self, s: slice) -> MutableSequence[Element]: ...
  95     def __len__(self) -> int: ...
  96     @overload
  97     def __setitem__(self, i: int, o: Element) -> None: ...
  98     @overload
  99     def __setitem__(self, s: slice, o: Iterable[Element]) -> None: ...
 100     if sys.version_info < (3, 9):
 101         def getchildren(self) -> list[Element]: ...
 102         def getiterator(self, tag: str | None = ...) -> list[Element]: ...
 103
 104 def SubElement(parent: Element, tag: str, attrib: dict[str, str] = ..., **extra: str) -> Element: ...
 105 def Comment(text: str | None = ...) -> Element: ...
 106 def ProcessingInstruction(target: str, text: str | None = ...) -> Element: ...
 107
 108 PI: Callable[..., Element]
 109
 110 class QName:
 111     text: str
 112     def __init__(self, text_or_uri: str, tag: str | None = ...) -> None: ...
 113
 114 class ElementTree:
 115     def __init__(self, element: Element | None = ..., file: _File | None = ...) -> None: ...
 116     def getroot(self) -> Element: ...
 117     def parse(self, source: _File, parser: XMLParser | None = ...) -> Element: ...
 118     def iter(self, tag: str | None = ...) -> Generator[Element, None, None]: ...
 119     if sys.version_info < (3, 9):
 120         def getiterator(self, tag: str | None = ...) -> list[Element]: ...
 121     def find(self, path: str, namespaces: dict[str, str] | None = ...) -> Element | None: ...
 122     @overload
 123     def findtext(self, path: str, default: None = ..., namespaces: dict[str, str] | None = ...) -> str | None: ...
 124     @overload
 125     def findtext(self, path: str, default: _T, namespaces: dict[str, str] | None = ...) -> _T | str: ...
 126     def findall(self, path: str, namespaces: dict[str, str] | None = ...) -> list[Element]: ...
 127     def iterfind(self, path: str, namespaces: dict[str, str] | None = ...) -> Generator[Element, None, None]: ...
 128     def write(
 129         self,
 130         file_or_filename: _File,
 131         encoding: str | None = ...,
 132         xml_declaration: bool | None = ...,
 133         default_namespace: str | None = ...,
 134         method: str | None = ...,
 135         *,
 136         short_empty_elements: bool = ...,
 137     ) -> None: ...
 138     def write_c14n(self, file: _File) -> None: ...
 139
 140 def register_namespace(prefix: str, uri: str) -> None: ...
 141
 142 if sys.version_info >= (3, 8):
 143     @overload
 144     def tostring(
 145         element: Element,
 146         encoding: None = ...,
 147         method: str | None = ...,
 148         *,
 149         xml_declaration: bool | None = ...,
 150         default_namespace: str | None = ...,
 151         short_empty_elements: bool = ...,
 152     ) -> bytes: ...
 153     @overload
 154     def tostring(
 155         element: Element,
 156         encoding: Literal["unicode"],
 157         method: str | None = ...,
 158         *,
 159         xml_declaration: bool | None = ...,
 160         default_namespace: str | None = ...,
 161         short_empty_elements: bool = ...,
 162     ) -> str: ...
 163     @overload
 164     def tostring(
 165         element: Element,
 166         encoding: str,
 167         method: str | None = ...,
 168         *,
 169         xml_declaration: bool | None = ...,
 170         default_namespace: str | None = ...,
 171         short_empty_elements: bool = ...,
 172     ) -> Any: ...
 173     @overload
 174     def tostringlist(
 175         element: Element,
 176         encoding: None = ...,
 177         method: str | None = ...,
 178         *,
 179         xml_declaration: bool | None = ...,
 180         default_namespace: str | None = ...,
 181         short_empty_elements: bool = ...,
 182     ) -> list[bytes]: ...
 183     @overload
 184     def tostringlist(
 185         element: Element,
 186         encoding: Literal["unicode"],
 187         method: str | None = ...,
 188         *,
 189         xml_declaration: bool | None = ...,
 190         default_namespace: str | None = ...,
 191         short_empty_elements: bool = ...,
 192     ) -> list[str]: ...
 193     @overload
 194     def tostringlist(
 195         element: Element,
 196         encoding: str,
 197         method: str | None = ...,
 198         *,
 199         xml_declaration: bool | None = ...,
 200         default_namespace: str | None = ...,
 201         short_empty_elements: bool = ...,
 202     ) -> list[Any]: ...
 203
 204 else:
 205     @overload
 206     def tostring(
 207         element: Element, encoding: None = ..., method: str | None = ..., *, short_empty_elements: bool = ...
 208     ) -> bytes: ...
 209     @overload
 210     def tostring(
 211         element: Element, encoding: Literal["unicode"], method: str | None = ..., *, short_empty_elements: bool = ...
 212     ) -> str: ...
 213     @overload
 214     def tostring(element: Element, encoding: str, method: str | None = ..., *, short_empty_elements: bool = ...) -> Any: ...
 215     @overload
 216     def tostringlist(
 217         element: Element, encoding: None = ..., method: str | None = ..., *, short_empty_elements: bool = ...
 218     ) -> list[bytes]: ...
 219     @overload
 220     def tostringlist(
 221         element: Element, encoding: Literal["unicode"], method: str | None = ..., *, short_empty_elements: bool = ...
 222     ) -> list[str]: ...
 223     @overload
 224     def tostringlist(
 225         element: Element, encoding: str, method: str | None = ..., *, short_empty_elements: bool = ...
 226     ) -> list[Any]: ...
 227
 228 def dump(elem: Element) -> None: ...
 229
 230 if sys.version_info >= (3, 9):
 231     def indent(tree: Element | ElementTree, space: str = ..., level: int = ...) -> None: ...
 232
 233 def parse(source: _File, parser: XMLParser | None = ...) -> ElementTree: ...
 234 def iterparse(source: _File, events: Sequence[str] | None = ..., parser: XMLParser | None = ...) -> Iterator[tuple[str, Any]]: ...
 235
 236 class XMLPullParser:
 237     def __init__(self, events: Sequence[str] | None = ..., *, _parser: XMLParser | None = ...) -> None: ...
 238     def feed(self, data: bytes) -> None: ...
 239     def close(self) -> None: ...
 240     def read_events(self) -> Iterator[tuple[str, Element]]: ...
 241
 242 def XML(text: str | bytes, parser: XMLParser | None = ...) -> Element: ...
 243 def XMLID(text: str | bytes, parser: XMLParser | None = ...) -> tuple[Element, dict[str, Element]]: ...
 244
 245 # This is aliased to XML in the source.
 246 fromstring = XML
 247
 248 def fromstringlist(sequence: Sequence[str | bytes], parser: XMLParser | None = ...) -> Element: ...
 249
 250 # This type is both not precise enough and too precise. The TreeBuilder
 251 # requires the elementfactory to accept tag and attrs in its args and produce
 252 # some kind of object that has .text and .tail properties.
 253 # I've chosen to constrain the ElementFactory to always produce an Element
 254 # because that is how almost everyone will use it.
 255 # Unfortunately, the type of the factory arguments is dependent on how
 256 # TreeBuilder is called by client code (they could pass strs, bytes or whatever);
 257 # but we don't want to use a too-broad type, or it would be too hard to write
 258 # elementfactories.
 259 _ElementFactory = Callable[[Any, Dict[Any, Any]], Element]
 260
 261 class TreeBuilder:
 262     def __init__(self, element_factory: _ElementFactory | None = ...) -> None: ...
 263     def close(self) -> Element: ...
 264     def data(self, __data: str | bytes) -> None: ...
 265     def start(self, __tag: str | bytes, __attrs: dict[str | bytes, str | bytes]) -> Element: ...
 266     def end(self, __tag: str | bytes) -> Element: ...
 267
 268 if sys.version_info >= (3, 8):
 269     class C14NWriterTarget:
 270         def __init__(
 271             self,
 272             write: Callable[[str], Any],
 273             *,
 274             with_comments: bool = ...,
 275             strip_text: bool = ...,
 276             rewrite_prefixes: bool = ...,
 277             qname_aware_tags: Iterable[str] | None = ...,
 278             qname_aware_attrs: Iterable[str] | None = ...,
 279             exclude_attrs: Iterable[str] | None = ...,
 280             exclude_tags: Iterable[str] | None = ...,
 281         ) -> None: ...
 282
 283 class XMLParser:
 284     parser: Any
 285     target: Any
 286     # TODO-what is entity used for???
 287     entity: Any
 288     version: str
 289     if sys.version_info >= (3, 8):
 290         def __init__(self, *, target: Any = ..., encoding: str | None = ...) -> None: ...
 291     else:
 292         def __init__(self, html: int = ..., target: Any = ..., encoding: str | None = ...) -> None: ...
 293         def doctype(self, __name: str, __pubid: str, __system: str) -> None: ...
 294     def close(self) -> Any: ...
 295     def feed(self, __data: str | bytes) -> None: ...