Enable xml stubs (PY-39061)

GitOrigin-RevId: cbde80de3256af9b10f67851a92eec3cb0a8ce06

python/helpers/typeshed/stdlib/2and3/xml/__init__.pyi

@@ -0,0 +1 @@
+import xml.parsers as parsers

python/helpers/typeshed/stdlib/2and3/xml/etree/ElementInclude.pyi

@@ -0,0 +1,17 @@
+# Stubs for xml.etree.ElementInclude (Python 3.4)
+
+from typing import Union, Optional, Callable
+from xml.etree.ElementTree import Element
+
+XINCLUDE: str
+XINCLUDE_INCLUDE: str
+XINCLUDE_FALLBACK: str
+
+class FatalIncludeError(SyntaxError): ...
+
+def default_loader(href: Union[str, bytes, int], parse: str, encoding: Optional[str] = ...) -> Union[str, Element]: ...
+
+# TODO: loader is of type default_loader ie it takes a callable that has the
+# same signature as default_loader. But default_loader has a keyword argument
+# Which can't be represented using Callable...
+def include(elem: Element, loader: Optional[Callable[..., Union[str, Element]]] = ...) -> None: ...

python/helpers/typeshed/stdlib/2and3/xml/etree/ElementPath.pyi

@@ -0,0 +1,33 @@
+# Stubs for xml.etree.ElementPath (Python 3.4)
+
+from typing import Pattern, Dict, Generator, Tuple, List, Union, TypeVar, Callable, Optional
+from xml.etree.ElementTree import Element
+
+xpath_tokenizer_re: Pattern[str]
+
+_token = Tuple[str, str]
+_next = Callable[[], _token]
+_callback = Callable[[_SelectorContext, List[Element]], Generator[Element, None, None]]
+
+def xpath_tokenizer(pattern: str, namespaces: Optional[Dict[str, str]] = ...) -> Generator[_token, None, None]: ...
+def get_parent_map(context: _SelectorContext) -> Dict[Element, Element]: ...
+def prepare_child(next: _next, token: _token) -> _callback: ...
+def prepare_star(next: _next, token: _token) -> _callback: ...
+def prepare_self(next: _next, token: _token) -> _callback: ...
+def prepare_descendant(next: _next, token: _token) -> _callback: ...
+def prepare_parent(next: _next, token: _token) -> _callback: ...
+def prepare_predicate(next: _next, token: _token) -> _callback: ...
+
+ops: Dict[str, Callable[[_next, _token], _callback]]
+
+class _SelectorContext:
+    parent_map: Dict[Element, Element]
+    root: Element
+    def __init__(self, root: Element) -> None: ...
+
+_T = TypeVar('_T')
+
+def iterfind(elem: Element, path: str, namespaces: Optional[Dict[str, str]] = ...) -> List[Element]: ...
+def find(elem: Element, path: str, namespaces: Optional[Dict[str, str]] = ...) -> Optional[Element]: ...
+def findall(elem: Element, path: str, namespaces: Optional[Dict[str, str]] = ...) -> List[Element]: ...
+def findtext(elem: Element, path: str, default: Optional[_T] = ..., namespaces: Optional[Dict[str, str]] = ...) -> Union[_T, str]: ...

python/helpers/typeshed/stdlib/2and3/xml/etree/ElementTree.pyi

@@ -0,0 +1,259 @@
+# Stubs for xml.etree.ElementTree
+
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generator,
+    IO,
+    ItemsView,
+    Iterable,
+    Iterator,
+    KeysView,
+    List,
+    MutableSequence,
+    Optional,
+    Protocol,
+    Sequence,
+    Text,
+    Tuple,
+    TypeVar,
+    Union,
+    overload,
+)
+import io
+import sys
+
+if sys.version_info < (3,) or sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+VERSION: str
+
+class ParseError(SyntaxError):
+    code: int
+    position: Tuple[int, int]
+
+def iselement(element: object) -> bool: ...
+
+_T = TypeVar('_T')
+
+# Type for parser inputs. Parser will accept any unicode/str/bytes and coerce,
+# and this is true in py2 and py3 (even fromstringlist() in python3 can be
+# called with a heterogeneous list)
+_parser_input_type = Union[bytes, Text]
+
+# Type for individual tag/attr/ns/text values in args to most functions.
+# In py2, the library accepts str or unicode everywhere and coerces
+# aggressively.
+# In py3, bytes is not coerced to str and so use of bytes is probably an error,
+# so we exclude it. (why? the parser never produces bytes when it parses XML,
+# so e.g., element.get(b'name') will always return None for parsed XML, even if
+# there is a 'name' attribute.)
+_str_argument_type = Union[str, Text]
+
+# Type for return values from individual tag/attr/text values
+if sys.version_info >= (3,):
+    # note: in python3, everything comes out as str, yay:
+    _str_result_type = str
+else:
+    # in python2, if the tag/attribute/text wasn't decode-able as ascii, it
+    # comes out as a unicode string; otherwise it comes out as str. (see
+    # _fixtext function in the source). Client code knows best:
+    _str_result_type = Any
+
+_file_or_filename = Union[str, bytes, int, IO[Any]]
+
+if sys.version_info >= (3, 8):
+    class _Writeable(Protocol):
+        def write(self, __s: str) -> Any: ...
+
+    @overload
+    def canonicalize(
+        xml_data: Optional[_parser_input_type] = ...,
+        *,
+        out: None = ...,
+        from_file: Optional[_file_or_filename] = ...,
+        with_comments: bool = ...,
+        strip_text: bool = ...,
+        rewrite_prefixes: bool = ...,
+        qname_aware_tags: Optional[Iterable[str]] = ...,
+        qname_aware_attrs: Optional[Iterable[str]] = ...,
+        exclude_attrs: Optional[Iterable[str]] = ...,
+        exclude_tags: Optional[Iterable[str]] = ...,
+    ) -> str: ...
+    @overload
+    def canonicalize(
+        xml_data: Optional[_parser_input_type] = ...,
+        *,
+        out: _Writeable,
+        from_file: Optional[_file_or_filename] = ...,
+        with_comments: bool = ...,
+        strip_text: bool = ...,
+        rewrite_prefixes: bool = ...,
+        qname_aware_tags: Optional[Iterable[str]] = ...,
+        qname_aware_attrs: Optional[Iterable[str]] = ...,
+        exclude_attrs: Optional[Iterable[str]] = ...,
+        exclude_tags: Optional[Iterable[str]] = ...,
+    ) -> None: ...
+
+class Element(MutableSequence[Element]):
+    tag: _str_result_type
+    attrib: Dict[_str_result_type, _str_result_type]
+    text: Optional[_str_result_type]
+    tail: Optional[_str_result_type]
+    def __init__(self, tag: Union[_str_argument_type, Callable[..., Element]], attrib: Dict[_str_argument_type, _str_argument_type] = ..., **extra: _str_argument_type) -> None: ...
+    def append(self, subelement: Element) -> None: ...
+    def clear(self) -> None: ...
+    def copy(self) -> Element: ...
+    def extend(self, elements: Iterable[Element]) -> None: ...
+    def find(self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...) -> Optional[Element]: ...
+    def findall(self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...) -> List[Element]: ...
+    @overload
+    def findtext(self, path: _str_argument_type, *, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...) -> Optional[_str_result_type]: ...
+    @overload
+    def findtext(self, path: _str_argument_type, default: _T, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...) -> Union[_T, _str_result_type]: ...
+    @overload
+    def get(self, key: _str_argument_type) -> Optional[_str_result_type]: ...
+    @overload
+    def get(self, key: _str_argument_type, default: _T) -> Union[_str_result_type, _T]: ...
+    def getchildren(self) -> List[Element]: ...
+    def getiterator(self, tag: Optional[_str_argument_type] = ...) -> List[Element]: ...
+    if sys.version_info >= (3, 2):
+        def insert(self, index: int, subelement: Element) -> None: ...
+    else:
+        def insert(self, index: int, element: Element) -> None: ...
+    def items(self) -> ItemsView[_str_result_type, _str_result_type]: ...
+    def iter(self, tag: Optional[_str_argument_type] = ...) -> Generator[Element, None, None]: ...
+    def iterfind(self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...) -> List[Element]: ...
+    def itertext(self) -> Generator[_str_result_type, None, None]: ...
+    def keys(self) -> KeysView[_str_result_type]: ...
+    def makeelement(self, tag: _str_argument_type, attrib: Dict[_str_argument_type, _str_argument_type]) -> Element: ...
+    def remove(self, subelement: Element) -> None: ...
+    def set(self, key: _str_argument_type, value: _str_argument_type) -> None: ...
+    def __bool__(self) -> bool: ...
+    def __delitem__(self, i: Union[int, slice]) -> None: ...
+    @overload
+    def __getitem__(self, i: int) -> Element: ...
+    @overload
+    def __getitem__(self, s: slice) -> MutableSequence[Element]: ...
+    def __len__(self) -> int: ...
+    @overload
+    def __setitem__(self, i: int, o: Element) -> None: ...
+    @overload
+    def __setitem__(self, s: slice, o: Iterable[Element]) -> None: ...
+
+
+def SubElement(parent: Element, tag: _str_argument_type, attrib: Dict[_str_argument_type, _str_argument_type] = ..., **extra: _str_argument_type) -> Element: ...
+def Comment(text: Optional[_str_argument_type] = ...) -> Element: ...
+def ProcessingInstruction(target: _str_argument_type, text: Optional[_str_argument_type] = ...) -> Element: ...
+
+PI: Callable[..., Element]
+
+class QName:
+    text: str
+    def __init__(self, text_or_uri: _str_argument_type, tag: Optional[_str_argument_type] = ...) -> None: ...
+
+class ElementTree:
+    def __init__(self, element: Optional[Element] = ..., file: Optional[_file_or_filename] = ...) -> None: ...
+    def getroot(self) -> Element: ...
+    def parse(self, source: _file_or_filename, parser: Optional[XMLParser] = ...) -> Element: ...
+    def iter(self, tag: Optional[_str_argument_type] = ...) -> Generator[Element, None, None]: ...
+    def getiterator(self, tag: Optional[_str_argument_type] = ...) -> List[Element]: ...
+    def find(self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...) -> Optional[Element]: ...
+    @overload
+    def findtext(self, path: _str_argument_type, *, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...) -> Optional[_str_result_type]: ...
+    @overload
+    def findtext(self, path: _str_argument_type, default: _T, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...) -> Union[_T, _str_result_type]: ...
+    def findall(self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...) -> List[Element]: ...
+    def iterfind(self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...) -> List[Element]: ...
+    if sys.version_info >= (3, 4):
+        def write(self, file_or_filename: _file_or_filename, encoding: Optional[str] = ..., xml_declaration: Optional[bool] = ..., default_namespace: Optional[_str_argument_type] = ..., method: Optional[str] = ..., *, short_empty_elements: bool = ...) -> None: ...
+    else:
+        def write(self, file_or_filename: _file_or_filename, encoding: Optional[str] = ..., xml_declaration: Optional[bool] = ..., default_namespace: Optional[_str_argument_type] = ..., method: Optional[str] = ...) -> None: ...
+    def write_c14n(self, file: _file_or_filename) -> None: ...
+
+def register_namespace(prefix: _str_argument_type, uri: _str_argument_type) -> None: ...
+if sys.version_info >= (3,):
+    @overload
+    def tostring(element: Element, encoding: None = ..., method: Optional[str] = ..., *, short_empty_elements: bool = ...) -> bytes: ...
+    @overload
+    def tostring(element: Element, encoding: Literal["unicode"], method: Optional[str] = ..., *, short_empty_elements: bool = ...) -> str: ...
+    @overload
+    def tostring(element: Element, encoding: str, method: Optional[str] = ..., *, short_empty_elements: bool = ...) -> Any: ...
+    @overload
+    def tostringlist(element: Element, encoding: None = ..., method: Optional[str] = ..., *, short_empty_elements: bool = ...) -> List[bytes]: ...
+    @overload
+    def tostringlist(element: Element, encoding: Literal["unicode"], method: Optional[str] = ..., *, short_empty_elements: bool = ...) -> List[str]: ...
+    @overload
+    def tostringlist(element: Element, encoding: str, method: Optional[str] = ..., *, short_empty_elements: bool = ...) -> List[Any]: ...
+else:
+    def tostring(element: Element, encoding: Optional[str] = ..., method: Optional[str] = ...) -> bytes: ...
+    def tostringlist(element: Element, encoding: Optional[str] = ..., method: Optional[str] = ...) -> List[bytes]: ...
+def dump(elem: Element) -> None: ...
+def parse(source: _file_or_filename, parser: Optional[XMLParser] = ...) -> ElementTree: ...
+def iterparse(source: _file_or_filename, events: Optional[Sequence[str]] = ..., parser: Optional[XMLParser] = ...) -> Iterator[Tuple[str, Any]]: ...
+
+if sys.version_info >= (3, 4):
+    class XMLPullParser:
+        def __init__(self, events: Optional[Sequence[str]] = ..., *, _parser: Optional[XMLParser] = ...) -> None: ...
+        def feed(self, data: bytes) -> None: ...
+        def close(self) -> None: ...
+        def read_events(self) -> Iterator[Tuple[str, Element]]: ...
+
+def XML(text: _parser_input_type, parser: Optional[XMLParser] = ...) -> Element: ...
+def XMLID(text: _parser_input_type, parser: Optional[XMLParser] = ...) -> Tuple[Element, Dict[_str_result_type, Element]]: ...
+
+# This is aliased to XML in the source.
+fromstring = XML
+
+def fromstringlist(sequence: Sequence[_parser_input_type], parser: Optional[XMLParser] = ...) -> Element: ...
+
+# This type is both not precise enough and too precise. The TreeBuilder
+# requires the elementfactory to accept tag and attrs in its args and produce
+# some kind of object that has .text and .tail properties.
+# I've chosen to constrain the ElementFactory to always produce an Element
+# because that is how almost everyone will use it.
+# Unfortunately, the type of the factory arguments is dependent on how
+# TreeBuilder is called by client code (they could pass strs, bytes or whatever);
+# but we don't want to use a too-broad type, or it would be too hard to write
+# elementfactories.
+_ElementFactory = Callable[[Any, Dict[Any, Any]], Element]
+
+class TreeBuilder:
+    def __init__(self, element_factory: Optional[_ElementFactory] = ...) -> None: ...
+    def close(self) -> Element: ...
+    def data(self, data: _parser_input_type) -> None: ...
+    def start(self, tag: _parser_input_type, attrs: Dict[_parser_input_type, _parser_input_type]) -> Element: ...
+    def end(self, tag: _parser_input_type) -> Element: ...
+
+if sys.version_info >= (3, 8):
+    class C14NWriterTarget:
+        def __init__(
+            self,
+            write: Callable[[str], Any],
+            *,
+            with_comments: bool = ...,
+            strip_text: bool = ...,
+            rewrite_prefixes: bool = ...,
+            qname_aware_tags: Optional[Iterable[str]] = ...,
+            qname_aware_attrs: Optional[Iterable[str]] = ...,
+            exclude_attrs: Optional[Iterable[str]] = ...,
+            exclude_tags: Optional[Iterable[str]] = ...,
+        ) -> None: ...
+
+
+class XMLParser:
+    parser: Any
+    target: TreeBuilder
+    # TODO-what is entity used for???
+    entity: Any
+    version: str
+    if sys.version_info >= (3, 8):
+        def __init__(self, *, target: Optional[TreeBuilder] = ..., encoding: Optional[str] = ...) -> None: ...
+    else:
+        def __init__(self, html: int = ..., target: Optional[TreeBuilder] = ..., encoding: Optional[str] = ...) -> None: ...
+        def doctype(self, name: str, pubid: str, system: str) -> None: ...
+    def close(self) -> Element: ...
+    def feed(self, data: _parser_input_type) -> None: ...

python/helpers/typeshed/stdlib/2and3/xml/etree/cElementTree.pyi

@@ -0,0 +1,3 @@
+# Stubs for xml.etree.cElementTree (Python 3.4)
+
+from xml.etree.ElementTree import *  # noqa: F403

python/helpers/typeshed/stdlib/2and3/xml/parsers/__init__.pyi

@@ -0,0 +1 @@
+import xml.parsers.expat as expat

python/helpers/typeshed/stdlib/2and3/xml/parsers/expat/__init__.pyi

@@ -0,0 +1 @@
+from pyexpat import *

python/helpers/typeshed/stdlib/2and3/xml/parsers/expat/errors.pyi

@@ -0,0 +1 @@
+from pyexpat.errors import *

python/helpers/typeshed/stdlib/2and3/xml/parsers/expat/model.pyi

@@ -0,0 +1 @@
+from pyexpat.model import *

python/helpers/typeshed/stdlib/2and3/xml/sax/__init__.pyi

@@ -0,0 +1,34 @@
+from typing import Any, List, NoReturn, Optional, Text, Union, IO
+
+import xml.sax
+from xml.sax.xmlreader import InputSource, Locator
+from xml.sax.handler import ContentHandler, ErrorHandler
+
+class SAXException(Exception):
+    def __init__(self, msg: str, exception: Optional[Exception] = ...) -> None: ...
+    def getMessage(self) -> str: ...
+    def getException(self) -> Exception: ...
+    def __getitem__(self, ix: Any) -> NoReturn: ...
+
+class SAXParseException(SAXException):
+    def __init__(self, msg: str, exception: Exception, locator: Locator) -> None: ...
+    def getColumnNumber(self) -> int: ...
+    def getLineNumber(self) -> int: ...
+    def getPublicId(self): ...
+    def getSystemId(self): ...
+
+class SAXNotRecognizedException(SAXException): ...
+class SAXNotSupportedException(SAXException): ...
+class SAXReaderNotAvailable(SAXNotSupportedException): ...
+
+default_parser_list: List[str]
+
+def make_parser(parser_list: List[str] = ...) -> xml.sax.xmlreader.XMLReader: ...
+
+def parse(source: Union[str, IO[str]], handler: xml.sax.handler.ContentHandler,
+          errorHandler: xml.sax.handler.ErrorHandler = ...) -> None: ...
+
+def parseString(string: Union[bytes, Text], handler: xml.sax.handler.ContentHandler,
+                errorHandler: Optional[xml.sax.handler.ErrorHandler] = ...) -> None: ...
+
+def _create_parser(parser_name: str) -> xml.sax.xmlreader.XMLReader: ...

python/helpers/typeshed/stdlib/2and3/xml/sax/handler.pyi

@@ -0,0 +1,46 @@
+from typing import Any
+
+version: Any
+
+class ErrorHandler:
+    def error(self, exception): ...
+    def fatalError(self, exception): ...
+    def warning(self, exception): ...
+
+class ContentHandler:
+    def __init__(self) -> None: ...
+    def setDocumentLocator(self, locator): ...
+    def startDocument(self): ...
+    def endDocument(self): ...
+    def startPrefixMapping(self, prefix, uri): ...
+    def endPrefixMapping(self, prefix): ...
+    def startElement(self, name, attrs): ...
+    def endElement(self, name): ...
+    def startElementNS(self, name, qname, attrs): ...
+    def endElementNS(self, name, qname): ...
+    def characters(self, content): ...
+    def ignorableWhitespace(self, whitespace): ...
+    def processingInstruction(self, target, data): ...
+    def skippedEntity(self, name): ...
+
+class DTDHandler:
+    def notationDecl(self, name, publicId, systemId): ...
+    def unparsedEntityDecl(self, name, publicId, systemId, ndata): ...
+
+class EntityResolver:
+    def resolveEntity(self, publicId, systemId): ...
+
+feature_namespaces: Any
+feature_namespace_prefixes: Any
+feature_string_interning: Any
+feature_validation: Any
+feature_external_ges: Any
+feature_external_pes: Any
+all_features: Any
+property_lexical_handler: Any
+property_declaration_handler: Any
+property_dom_node: Any
+property_xml_string: Any
+property_encoding: Any
+property_interning_dict: Any
+all_properties: Any

python/helpers/typeshed/stdlib/2and3/xml/sax/saxutils.pyi

@@ -0,0 +1,58 @@
+import sys
+from typing import Mapping, Text
+
+from xml.sax import handler
+from xml.sax import xmlreader
+
+def escape(data: Text, entities: Mapping[Text, Text] = ...) -> Text: ...
+def unescape(data: Text, entities: Mapping[Text, Text] = ...) -> Text: ...
+def quoteattr(data: Text, entities: Mapping[Text, Text] = ...) -> Text: ...
+
+class XMLGenerator(handler.ContentHandler):
+    if sys.version_info >= (3, 0):
+        def __init__(self, out=..., encoding=..., short_empty_elements: bool = ...) -> None: ...
+    else:
+        def __init__(self, out=..., encoding=...) -> None: ...
+    def startDocument(self): ...
+    def endDocument(self): ...
+    def startPrefixMapping(self, prefix, uri): ...
+    def endPrefixMapping(self, prefix): ...
+    def startElement(self, name, attrs): ...
+    def endElement(self, name): ...
+    def startElementNS(self, name, qname, attrs): ...
+    def endElementNS(self, name, qname): ...
+    def characters(self, content): ...
+    def ignorableWhitespace(self, content): ...
+    def processingInstruction(self, target, data): ...
+
+class XMLFilterBase(xmlreader.XMLReader):
+    def __init__(self, parent=...) -> None: ...
+    def error(self, exception): ...
+    def fatalError(self, exception): ...
+    def warning(self, exception): ...
+    def setDocumentLocator(self, locator): ...
+    def startDocument(self): ...
+    def endDocument(self): ...
+    def startPrefixMapping(self, prefix, uri): ...
+    def endPrefixMapping(self, prefix): ...
+    def startElement(self, name, attrs): ...
+    def endElement(self, name): ...
+    def startElementNS(self, name, qname, attrs): ...
+    def endElementNS(self, name, qname): ...
+    def characters(self, content): ...
+    def ignorableWhitespace(self, chars): ...
+    def processingInstruction(self, target, data): ...
+    def skippedEntity(self, name): ...
+    def notationDecl(self, name, publicId, systemId): ...
+    def unparsedEntityDecl(self, name, publicId, systemId, ndata): ...
+    def resolveEntity(self, publicId, systemId): ...
+    def parse(self, source): ...
+    def setLocale(self, locale): ...
+    def getFeature(self, name): ...
+    def setFeature(self, name, state): ...
+    def getProperty(self, name): ...
+    def setProperty(self, name, value): ...
+    def getParent(self): ...
+    def setParent(self, parent): ...
+
+def prepare_input_source(source, base=...): ...

python/helpers/typeshed/stdlib/2and3/xml/sax/xmlreader.pyi

@@ -0,0 +1,71 @@
+class XMLReader:
+    def __init__(self) -> None: ...
+    def parse(self, source): ...
+    def getContentHandler(self): ...
+    def setContentHandler(self, handler): ...
+    def getDTDHandler(self): ...
+    def setDTDHandler(self, handler): ...
+    def getEntityResolver(self): ...
+    def setEntityResolver(self, resolver): ...
+    def getErrorHandler(self): ...
+    def setErrorHandler(self, handler): ...
+    def setLocale(self, locale): ...
+    def getFeature(self, name): ...
+    def setFeature(self, name, state): ...
+    def getProperty(self, name): ...
+    def setProperty(self, name, value): ...
+
+class IncrementalParser(XMLReader):
+    def __init__(self, bufsize=...) -> None: ...
+    def parse(self, source): ...
+    def feed(self, data): ...
+    def prepareParser(self, source): ...
+    def close(self): ...
+    def reset(self): ...
+
+class Locator:
+    def getColumnNumber(self): ...
+    def getLineNumber(self): ...
+    def getPublicId(self): ...
+    def getSystemId(self): ...
+
+class InputSource:
+    def __init__(self, system_id=...) -> None: ...
+    def setPublicId(self, public_id): ...
+    def getPublicId(self): ...
+    def setSystemId(self, system_id): ...
+    def getSystemId(self): ...
+    def setEncoding(self, encoding): ...
+    def getEncoding(self): ...
+    def setByteStream(self, bytefile): ...
+    def getByteStream(self): ...
+    def setCharacterStream(self, charfile): ...
+    def getCharacterStream(self): ...
+
+class AttributesImpl:
+    def __init__(self, attrs) -> None: ...
+    def getLength(self): ...
+    def getType(self, name): ...
+    def getValue(self, name): ...
+    def getValueByQName(self, name): ...
+    def getNameByQName(self, name): ...
+    def getQNameByName(self, name): ...
+    def getNames(self): ...
+    def getQNames(self): ...
+    def __len__(self): ...
+    def __getitem__(self, name): ...
+    def keys(self): ...
+    def has_key(self, name): ...
+    def __contains__(self, name): ...
+    def get(self, name, alternative=...): ...
+    def copy(self): ...
+    def items(self): ...
+    def values(self): ...
+
+class AttributesNSImpl(AttributesImpl):
+    def __init__(self, attrs, qnames) -> None: ...
+    def getValueByQName(self, name): ...
+    def getNameByQName(self, name): ...
+    def getQNameByName(self, name): ...
+    def getQNames(self): ...
+    def copy(self): ...

python/tools/src/com/jetbrains/python/tools/PyTypeShedSync.kts

@@ -77,7 +77,8 @@ val whiteList = setOf(
   "unittest",
   "urllib",
   "uuid",
-  "werkzeug"
+  "werkzeug",
+  "xml"
 )
 
 println("Cleaning")