mypy-dev 1.9.0.dev0__py3-none-any.whl

mypy/typeshed/stdlib/xml/dom/minicompat.pyi

@@ -0,0 +1,22 @@
+from collections.abc import Iterable
+from typing import Any, Literal, TypeVar
+
+__all__ = ["NodeList", "EmptyNodeList", "StringTypes", "defproperty"]
+
+_T = TypeVar("_T")
+
+StringTypes: tuple[type[str]]
+
+class NodeList(list[_T]):
+    @property
+    def length(self) -> int: ...
+    def item(self, index: int) -> _T | None: ...
+
+class EmptyNodeList(tuple[()]):
+    @property
+    def length(self) -> Literal[0]: ...
+    def item(self, index: int) -> None: ...
+    def __add__(self, other: Iterable[_T]) -> NodeList[_T]: ...  # type: ignore[override]
+    def __radd__(self, other: Iterable[_T]) -> NodeList[_T]: ...
+
+def defproperty(klass: type[Any], name: str, doc: str) -> None: ...

mypy/typeshed/stdlib/xml/dom/minidom.pyi

@@ -0,0 +1,404 @@
+import sys
+import xml.dom
+from _typeshed import Incomplete, ReadableBuffer, SupportsRead, SupportsWrite
+from typing import Literal, NoReturn, TypeVar, overload
+from typing_extensions import Self
+from xml.dom.minicompat import NodeList
+from xml.dom.xmlbuilder import DocumentLS, DOMImplementationLS
+from xml.sax.xmlreader import XMLReader
+
+_N = TypeVar("_N", bound=Node)
+
+def parse(
+    file: str | SupportsRead[ReadableBuffer | str], parser: XMLReader | None = None, bufsize: int | None = None
+) -> Document: ...
+def parseString(string: str | ReadableBuffer, parser: XMLReader | None = None) -> Document: ...
+def getDOMImplementation(features=None) -> DOMImplementation | None: ...
+
+class Node(xml.dom.Node):
+    namespaceURI: str | None
+    parentNode: Incomplete
+    ownerDocument: Incomplete
+    nextSibling: Incomplete
+    previousSibling: Incomplete
+    prefix: Incomplete
+    @property
+    def firstChild(self) -> Node | None: ...
+    @property
+    def lastChild(self) -> Node | None: ...
+    @property
+    def localName(self) -> str | None: ...
+    def __bool__(self) -> Literal[True]: ...
+    if sys.version_info >= (3, 9):
+        @overload
+        def toxml(self, encoding: str, standalone: bool | None = None) -> bytes: ...
+        @overload
+        def toxml(self, encoding: None = None, standalone: bool | None = None) -> str: ...
+        @overload
+        def toprettyxml(
+            self,
+            indent: str = "\t",
+            newl: str = "\n",
+            # Handle any case where encoding is not provided or where it is passed with None
+            encoding: None = None,
+            standalone: bool | None = None,
+        ) -> str: ...
+        @overload
+        def toprettyxml(
+            self,
+            indent: str,
+            newl: str,
+            # Handle cases where encoding is passed as str *positionally*
+            encoding: str,
+            standalone: bool | None = None,
+        ) -> bytes: ...
+        @overload
+        def toprettyxml(
+            self,
+            indent: str = "\t",
+            newl: str = "\n",
+            # Handle all cases where encoding is passed as a keyword argument; because standalone
+            # comes after, it will also have to be a keyword arg if encoding is
+            *,
+            encoding: str,
+            standalone: bool | None = None,
+        ) -> bytes: ...
+    else:
+        @overload
+        def toxml(self, encoding: str) -> bytes: ...
+        @overload
+        def toxml(self, encoding: None = None) -> str: ...
+        @overload
+        def toprettyxml(
+            self,
+            indent: str = "\t",
+            newl: str = "\n",
+            # Handle any case where encoding is not provided or where it is passed with None
+            encoding: None = None,
+        ) -> str: ...
+        @overload
+        def toprettyxml(
+            self,
+            indent: str,
+            newl: str,
+            # Handle cases where encoding is passed as str *positionally*
+            encoding: str,
+        ) -> bytes: ...
+        @overload
+        def toprettyxml(
+            self,
+            indent: str = "\t",
+            newl: str = "\n",
+            # Handle all cases where encoding is passed as a keyword argument
+            *,
+            encoding: str,
+        ) -> bytes: ...
+
+    def hasChildNodes(self) -> bool: ...
+    def insertBefore(self, newChild, refChild): ...
+    def appendChild(self, node: _N) -> _N: ...
+    def replaceChild(self, newChild, oldChild): ...
+    def removeChild(self, oldChild): ...
+    def normalize(self) -> None: ...
+    def cloneNode(self, deep): ...
+    def isSupported(self, feature, version): ...
+    def isSameNode(self, other): ...
+    def getInterface(self, feature): ...
+    def getUserData(self, key): ...
+    def setUserData(self, key, data, handler): ...
+    childNodes: Incomplete
+    def unlink(self) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(self, et, ev, tb) -> None: ...
+
+class DocumentFragment(Node):
+    nodeType: int
+    nodeName: str
+    nodeValue: Incomplete
+    attributes: Incomplete
+    parentNode: Incomplete
+    childNodes: Incomplete
+    def __init__(self) -> None: ...
+
+class Attr(Node):
+    name: str
+    nodeType: int
+    attributes: Incomplete
+    specified: bool
+    ownerElement: Incomplete
+    namespaceURI: str | None
+    childNodes: Incomplete
+    nodeName: Incomplete
+    nodeValue: str
+    value: str
+    prefix: Incomplete
+    def __init__(
+        self, qName: str, namespaceURI: str | None = None, localName: str | None = None, prefix: Incomplete | None = None
+    ) -> None: ...
+    def unlink(self) -> None: ...
+    @property
+    def isId(self) -> bool: ...
+    @property
+    def schemaType(self): ...
+
+class NamedNodeMap:
+    def __init__(self, attrs, attrsNS, ownerElement) -> None: ...
+    def item(self, index): ...
+    def items(self): ...
+    def itemsNS(self): ...
+    def __contains__(self, key): ...
+    def keys(self): ...
+    def keysNS(self): ...
+    def values(self): ...
+    def get(self, name: str, value: Incomplete | None = None): ...
+    def __len__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ge__(self, other: NamedNodeMap) -> bool: ...
+    def __gt__(self, other: NamedNodeMap) -> bool: ...
+    def __le__(self, other: NamedNodeMap) -> bool: ...
+    def __lt__(self, other: NamedNodeMap) -> bool: ...
+    def __getitem__(self, attname_or_tuple: tuple[str, str | None] | str): ...
+    def __setitem__(self, attname: str, value: Attr | str) -> None: ...
+    def getNamedItem(self, name: str) -> Attr | None: ...
+    def getNamedItemNS(self, namespaceURI: str, localName: str | None) -> Attr | None: ...
+    def removeNamedItem(self, name: str) -> Attr: ...
+    def removeNamedItemNS(self, namespaceURI: str, localName: str | None): ...
+    def setNamedItem(self, node: Attr) -> Attr: ...
+    def setNamedItemNS(self, node: Attr) -> Attr: ...
+    def __delitem__(self, attname_or_tuple: tuple[str, str | None] | str) -> None: ...
+    @property
+    def length(self) -> int: ...
+
+AttributeList = NamedNodeMap
+
+class TypeInfo:
+    namespace: Incomplete | None
+    name: str
+    def __init__(self, namespace: Incomplete | None, name: str) -> None: ...
+
+class Element(Node):
+    nodeType: int
+    nodeValue: Incomplete
+    schemaType: Incomplete
+    parentNode: Incomplete
+    tagName: str
+    nodeName: str
+    prefix: Incomplete
+    namespaceURI: str | None
+    childNodes: Incomplete
+    nextSibling: Incomplete
+    def __init__(
+        self, tagName, namespaceURI: str | None = None, prefix: Incomplete | None = None, localName: Incomplete | None = None
+    ) -> None: ...
+    def unlink(self) -> None: ...
+    def getAttribute(self, attname: str) -> str: ...
+    def getAttributeNS(self, namespaceURI: str, localName): ...
+    def setAttribute(self, attname: str, value: str) -> None: ...
+    def setAttributeNS(self, namespaceURI: str, qualifiedName: str, value) -> None: ...
+    def getAttributeNode(self, attrname: str): ...
+    def getAttributeNodeNS(self, namespaceURI: str, localName): ...
+    def setAttributeNode(self, attr): ...
+    setAttributeNodeNS: Incomplete
+    def removeAttribute(self, name: str) -> None: ...
+    def removeAttributeNS(self, namespaceURI: str, localName) -> None: ...
+    def removeAttributeNode(self, node): ...
+    removeAttributeNodeNS: Incomplete
+    def hasAttribute(self, name: str) -> bool: ...
+    def hasAttributeNS(self, namespaceURI: str, localName) -> bool: ...
+    def getElementsByTagName(self, name: str) -> NodeList[Element]: ...
+    def getElementsByTagNameNS(self, namespaceURI: str, localName: str) -> NodeList[Element]: ...
+    def writexml(self, writer: SupportsWrite[str], indent: str = "", addindent: str = "", newl: str = "") -> None: ...
+    def hasAttributes(self) -> bool: ...
+    def setIdAttribute(self, name) -> None: ...
+    def setIdAttributeNS(self, namespaceURI: str, localName) -> None: ...
+    def setIdAttributeNode(self, idAttr) -> None: ...
+    @property
+    def attributes(self) -> NamedNodeMap: ...
+
+class Childless:
+    attributes: Incomplete
+    childNodes: Incomplete
+    firstChild: Incomplete
+    lastChild: Incomplete
+    def appendChild(self, node) -> NoReturn: ...
+    def hasChildNodes(self) -> bool: ...
+    def insertBefore(self, newChild, refChild) -> NoReturn: ...
+    def removeChild(self, oldChild) -> NoReturn: ...
+    def normalize(self) -> None: ...
+    def replaceChild(self, newChild, oldChild) -> NoReturn: ...
+
+class ProcessingInstruction(Childless, Node):
+    nodeType: int
+    target: Incomplete
+    data: Incomplete
+    def __init__(self, target, data) -> None: ...
+    nodeValue: Incomplete
+    nodeName: Incomplete
+    def writexml(self, writer: SupportsWrite[str], indent: str = "", addindent: str = "", newl: str = "") -> None: ...
+
+class CharacterData(Childless, Node):
+    ownerDocument: Incomplete
+    previousSibling: Incomplete
+    def __init__(self) -> None: ...
+    def __len__(self) -> int: ...
+    data: str
+    nodeValue: Incomplete
+    def substringData(self, offset: int, count: int) -> str: ...
+    def appendData(self, arg: str) -> None: ...
+    def insertData(self, offset: int, arg: str) -> None: ...
+    def deleteData(self, offset: int, count: int) -> None: ...
+    def replaceData(self, offset: int, count: int, arg: str) -> None: ...
+    @property
+    def length(self) -> int: ...
+
+class Text(CharacterData):
+    nodeType: int
+    nodeName: str
+    attributes: Incomplete
+    data: Incomplete
+    def splitText(self, offset): ...
+    def writexml(self, writer: SupportsWrite[str], indent: str = "", addindent: str = "", newl: str = "") -> None: ...
+    def replaceWholeText(self, content): ...
+    @property
+    def isWhitespaceInElementContent(self) -> bool: ...
+    @property
+    def wholeText(self) -> str: ...
+
+class Comment(CharacterData):
+    nodeType: int
+    nodeName: str
+    def __init__(self, data) -> None: ...
+    def writexml(self, writer: SupportsWrite[str], indent: str = "", addindent: str = "", newl: str = "") -> None: ...
+
+class CDATASection(Text):
+    nodeType: int
+    nodeName: str
+    def writexml(self, writer: SupportsWrite[str], indent: str = "", addindent: str = "", newl: str = "") -> None: ...
+
+class ReadOnlySequentialNamedNodeMap:
+    def __init__(self, seq=()) -> None: ...
+    def __len__(self) -> int: ...
+    def getNamedItem(self, name): ...
+    def getNamedItemNS(self, namespaceURI: str, localName): ...
+    def __getitem__(self, name_or_tuple): ...
+    def item(self, index): ...
+    def removeNamedItem(self, name) -> None: ...
+    def removeNamedItemNS(self, namespaceURI: str, localName) -> None: ...
+    def setNamedItem(self, node) -> None: ...
+    def setNamedItemNS(self, node) -> None: ...
+    @property
+    def length(self) -> int: ...
+
+class Identified:
+    publicId: Incomplete
+    systemId: Incomplete
+
+class DocumentType(Identified, Childless, Node):
+    nodeType: int
+    nodeValue: Incomplete
+    name: Incomplete
+    internalSubset: Incomplete
+    entities: Incomplete
+    notations: Incomplete
+    nodeName: Incomplete
+    def __init__(self, qualifiedName: str) -> None: ...
+    def cloneNode(self, deep): ...
+    def writexml(self, writer: SupportsWrite[str], indent: str = "", addindent: str = "", newl: str = "") -> None: ...
+
+class Entity(Identified, Node):
+    attributes: Incomplete
+    nodeType: int
+    nodeValue: Incomplete
+    actualEncoding: Incomplete
+    encoding: Incomplete
+    version: Incomplete
+    nodeName: Incomplete
+    notationName: Incomplete
+    childNodes: Incomplete
+    def __init__(self, name, publicId, systemId, notation) -> None: ...
+    def appendChild(self, newChild) -> NoReturn: ...
+    def insertBefore(self, newChild, refChild) -> NoReturn: ...
+    def removeChild(self, oldChild) -> NoReturn: ...
+    def replaceChild(self, newChild, oldChild) -> NoReturn: ...
+
+class Notation(Identified, Childless, Node):
+    nodeType: int
+    nodeValue: Incomplete
+    nodeName: Incomplete
+    def __init__(self, name, publicId, systemId) -> None: ...
+
+class DOMImplementation(DOMImplementationLS):
+    def hasFeature(self, feature: str, version: str | None) -> bool: ...
+    def createDocument(self, namespaceURI: str | None, qualifiedName: str | None, doctype: DocumentType | None) -> Document: ...
+    def createDocumentType(self, qualifiedName: str | None, publicId: str, systemId: str) -> DocumentType: ...
+    def getInterface(self, feature: str) -> Self | None: ...
+
+class ElementInfo:
+    tagName: Incomplete
+    def __init__(self, name) -> None: ...
+    def getAttributeType(self, aname): ...
+    def getAttributeTypeNS(self, namespaceURI: str, localName): ...
+    def isElementContent(self): ...
+    def isEmpty(self): ...
+    def isId(self, aname): ...
+    def isIdNS(self, namespaceURI: str, localName): ...
+
+class Document(Node, DocumentLS):
+    implementation: Incomplete
+    nodeType: int
+    nodeName: str
+    nodeValue: Incomplete
+    attributes: Incomplete
+    parentNode: Incomplete
+    previousSibling: Incomplete
+    nextSibling: Incomplete
+    actualEncoding: Incomplete
+    encoding: str | None
+    standalone: bool | None
+    version: Incomplete
+    strictErrorChecking: bool
+    errorHandler: Incomplete
+    documentURI: Incomplete
+    doctype: DocumentType | None
+    childNodes: Incomplete
+    def __init__(self) -> None: ...
+    def appendChild(self, node: _N) -> _N: ...
+    documentElement: Incomplete
+    def removeChild(self, oldChild): ...
+    def unlink(self) -> None: ...
+    def cloneNode(self, deep): ...
+    def createDocumentFragment(self) -> DocumentFragment: ...
+    def createElement(self, tagName: str) -> Element: ...
+    def createTextNode(self, data: str) -> Text: ...
+    def createCDATASection(self, data: str) -> CDATASection: ...
+    def createComment(self, data: str) -> Comment: ...
+    def createProcessingInstruction(self, target, data): ...
+    def createAttribute(self, qName) -> Attr: ...
+    def createElementNS(self, namespaceURI: str, qualifiedName: str): ...
+    def createAttributeNS(self, namespaceURI: str, qualifiedName: str) -> Attr: ...
+    def getElementById(self, id: str) -> Element | None: ...
+    def getElementsByTagName(self, name: str) -> NodeList[Element]: ...
+    def getElementsByTagNameNS(self, namespaceURI: str, localName: str) -> NodeList[Element]: ...
+    def isSupported(self, feature: str, version: str | None) -> bool: ...
+    def importNode(self, node, deep): ...
+    if sys.version_info >= (3, 9):
+        def writexml(
+            self,
+            writer: SupportsWrite[str],
+            indent: str = "",
+            addindent: str = "",
+            newl: str = "",
+            encoding: str | None = None,
+            standalone: bool | None = None,
+        ) -> None: ...
+    else:
+        def writexml(
+            self,
+            writer: SupportsWrite[str],
+            indent: str = "",
+            addindent: str = "",
+            newl: str = "",
+            encoding: Incomplete | None = None,
+        ) -> None: ...
+
+    def renameNode(self, n, namespaceURI: str, name): ...

mypy/typeshed/stdlib/xml/dom/pulldom.pyi

@@ -0,0 +1,94 @@
+import sys
+from _typeshed import Incomplete, SupportsRead
+from collections.abc import Sequence
+from typing import Literal
+from typing_extensions import TypeAlias
+from xml.dom.minidom import Document, DOMImplementation, Element, Text
+from xml.sax.handler import ContentHandler
+from xml.sax.xmlreader import XMLReader
+
+START_ELEMENT: Literal["START_ELEMENT"]
+END_ELEMENT: Literal["END_ELEMENT"]
+COMMENT: Literal["COMMENT"]
+START_DOCUMENT: Literal["START_DOCUMENT"]
+END_DOCUMENT: Literal["END_DOCUMENT"]
+PROCESSING_INSTRUCTION: Literal["PROCESSING_INSTRUCTION"]
+IGNORABLE_WHITESPACE: Literal["IGNORABLE_WHITESPACE"]
+CHARACTERS: Literal["CHARACTERS"]
+
+_DocumentFactory: TypeAlias = DOMImplementation | None
+_Node: TypeAlias = Document | Element | Text
+
+_Event: TypeAlias = tuple[
+    Literal[
+        Literal["START_ELEMENT"],
+        Literal["END_ELEMENT"],
+        Literal["COMMENT"],
+        Literal["START_DOCUMENT"],
+        Literal["END_DOCUMENT"],
+        Literal["PROCESSING_INSTRUCTION"],
+        Literal["IGNORABLE_WHITESPACE"],
+        Literal["CHARACTERS"],
+    ],
+    _Node,
+]
+
+class PullDOM(ContentHandler):
+    document: Document | None
+    documentFactory: _DocumentFactory
+    firstEvent: Incomplete
+    lastEvent: Incomplete
+    elementStack: Sequence[Incomplete]
+    pending_events: Sequence[Incomplete]
+    def __init__(self, documentFactory: _DocumentFactory = None) -> None: ...
+    def pop(self) -> Element: ...
+    def setDocumentLocator(self, locator) -> None: ...
+    def startPrefixMapping(self, prefix, uri) -> None: ...
+    def endPrefixMapping(self, prefix) -> None: ...
+    def startElementNS(self, name, tagName, attrs) -> None: ...
+    def endElementNS(self, name, tagName) -> None: ...
+    def startElement(self, name, attrs) -> None: ...
+    def endElement(self, name) -> None: ...
+    def comment(self, s) -> None: ...
+    def processingInstruction(self, target, data) -> None: ...
+    def ignorableWhitespace(self, chars) -> None: ...
+    def characters(self, chars) -> None: ...
+    def startDocument(self) -> None: ...
+    def buildDocument(self, uri, tagname): ...
+    def endDocument(self) -> None: ...
+    def clear(self) -> None: ...
+
+class ErrorHandler:
+    def warning(self, exception) -> None: ...
+    def error(self, exception) -> None: ...
+    def fatalError(self, exception) -> None: ...
+
+class DOMEventStream:
+    stream: SupportsRead[bytes] | SupportsRead[str]
+    parser: XMLReader
+    bufsize: int
+    def __init__(self, stream: SupportsRead[bytes] | SupportsRead[str], parser: XMLReader, bufsize: int) -> None: ...
+    pulldom: Incomplete
+    if sys.version_info < (3, 11):
+        def __getitem__(self, pos): ...
+
+    def __next__(self): ...
+    def __iter__(self): ...
+    def getEvent(self) -> _Event: ...
+    def expandNode(self, node: _Node) -> None: ...
+    def reset(self) -> None: ...
+    def clear(self) -> None: ...
+
+class SAX2DOM(PullDOM):
+    def startElementNS(self, name, tagName, attrs) -> None: ...
+    def startElement(self, name, attrs) -> None: ...
+    def processingInstruction(self, target, data) -> None: ...
+    def ignorableWhitespace(self, chars) -> None: ...
+    def characters(self, chars) -> None: ...
+
+default_bufsize: int
+
+def parse(
+    stream_or_string: str | SupportsRead[bytes] | SupportsRead[str], parser: XMLReader | None = None, bufsize: int | None = None
+) -> DOMEventStream: ...
+def parseString(string: str, parser: XMLReader | None = None) -> DOMEventStream: ...

mypy/typeshed/stdlib/xml/dom/xmlbuilder.pyi

@@ -0,0 +1,108 @@
+from _typeshed import Incomplete, Unused
+from typing import Any, Literal, NoReturn
+from typing_extensions import TypeAlias
+from urllib.request import OpenerDirector
+from xml.dom.expatbuilder import ExpatBuilder, ExpatBuilderNS
+from xml.dom.minidom import Node
+
+__all__ = ["DOMBuilder", "DOMEntityResolver", "DOMInputSource"]
+
+# UNKNOWN TYPES:
+# - `Options.errorHandler`.
+#       The same as `_DOMBuilderErrorHandlerType`?
+#       Maybe `xml.sax.handler.ErrorHandler`?
+# - Return type of DOMBuilder.getFeature().
+#       We could get rid of the `Incomplete` if we knew more
+#       about `Options.errorHandler`.
+
+# ALIASES REPRESENTING MORE UNKNOWN TYPES:
+
+# probably the same as `Options.errorHandler`?
+# Maybe `xml.sax.handler.ErrorHandler`?
+_DOMBuilderErrorHandlerType: TypeAlias = Incomplete | None
+# probably some kind of IO...
+_DOMInputSourceCharacterStreamType: TypeAlias = Incomplete | None
+# probably a string??
+_DOMInputSourceStringDataType: TypeAlias = Incomplete | None
+# probably a string??
+_DOMInputSourceEncodingType: TypeAlias = Incomplete | None
+
+class Options:
+    namespaces: int
+    namespace_declarations: bool
+    validation: bool
+    external_parameter_entities: bool
+    external_general_entities: bool
+    external_dtd_subset: bool
+    validate_if_schema: bool
+    validate: bool
+    datatype_normalization: bool
+    create_entity_ref_nodes: bool
+    entities: bool
+    whitespace_in_element_content: bool
+    cdata_sections: bool
+    comments: bool
+    charset_overrides_xml_encoding: bool
+    infoset: bool
+    supported_mediatypes_only: bool
+    errorHandler: Any | None
+    filter: DOMBuilderFilter | None  # a guess, but seems likely
+
+class DOMBuilder:
+    entityResolver: DOMEntityResolver | None  # a guess, but seems likely
+    errorHandler: _DOMBuilderErrorHandlerType
+    filter: DOMBuilderFilter | None  # a guess, but seems likely
+    ACTION_REPLACE: Literal[1]
+    ACTION_APPEND_AS_CHILDREN: Literal[2]
+    ACTION_INSERT_AFTER: Literal[3]
+    ACTION_INSERT_BEFORE: Literal[4]
+    def setFeature(self, name: str, state: int) -> None: ...
+    def supportsFeature(self, name: str) -> bool: ...
+    def canSetFeature(self, name: str, state: int) -> bool: ...
+    # getFeature could return any attribute from an instance of `Options`
+    def getFeature(self, name: str) -> Incomplete: ...
+    def parseURI(self, uri: str) -> ExpatBuilder | ExpatBuilderNS: ...
+    def parse(self, input: DOMInputSource) -> ExpatBuilder | ExpatBuilderNS: ...
+    # `input` and `cnode` argtypes for `parseWithContext` are unknowable
+    # as the function does nothing with them, and always raises an exception.
+    # But `input` is *probably* `DOMInputSource`?
+    def parseWithContext(self, input: Unused, cnode: Unused, action: Literal[1, 2, 3, 4]) -> NoReturn: ...
+
+class DOMEntityResolver:
+    def resolveEntity(self, publicId: str | None, systemId: str) -> DOMInputSource: ...
+
+class DOMInputSource:
+    byteStream: OpenerDirector | None
+    characterStream: _DOMInputSourceCharacterStreamType
+    stringData: _DOMInputSourceStringDataType
+    encoding: _DOMInputSourceEncodingType
+    publicId: str | None
+    systemId: str | None
+    baseURI: str | None
+
+class DOMBuilderFilter:
+    FILTER_ACCEPT: Literal[1]
+    FILTER_REJECT: Literal[2]
+    FILTER_SKIP: Literal[3]
+    FILTER_INTERRUPT: Literal[4]
+    whatToShow: int
+    def acceptNode(self, element: Unused) -> Literal[1]: ...
+    def startContainer(self, element: Unused) -> Literal[1]: ...
+
+class DocumentLS:
+    async_: bool
+    def abort(self) -> NoReturn: ...
+    # `load()` and `loadXML()` always raise exceptions
+    # so the argtypes of `uri` and `source` are unknowable.
+    # `source` is *probably* `DOMInputSource`?
+    # `uri` is *probably* a str? (see DOMBuilder.parseURI())
+    def load(self, uri: Unused) -> NoReturn: ...
+    def loadXML(self, source: Unused) -> NoReturn: ...
+    def saveXML(self, snode: Node | None) -> str: ...
+
+class DOMImplementationLS:
+    MODE_SYNCHRONOUS: Literal[1]
+    MODE_ASYNCHRONOUS: Literal[2]
+    def createDOMBuilder(self, mode: Literal[1], schemaType: None) -> DOMBuilder: ...
+    def createDOMWriter(self) -> NoReturn: ...
+    def createDOMInputSource(self) -> DOMInputSource: ...

mypy/typeshed/stdlib/xml/etree/ElementInclude.pyi

@@ -0,0 +1,28 @@
+import sys
+from _typeshed import FileDescriptorOrPath
+from collections.abc import Callable
+from xml.etree.ElementTree import Element
+
+XINCLUDE: str
+XINCLUDE_INCLUDE: str
+XINCLUDE_FALLBACK: str
+
+if sys.version_info >= (3, 9):
+    DEFAULT_MAX_INCLUSION_DEPTH: int
+
+class FatalIncludeError(SyntaxError): ...
+
+def default_loader(href: FileDescriptorOrPath, parse: str, encoding: str | None = None) -> 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...
+if sys.version_info >= (3, 9):
+    def include(
+        elem: Element, loader: Callable[..., str | Element] | None = None, base_url: str | None = None, max_depth: int | None = 6
+    ) -> None: ...
+
+    class LimitedRecursiveIncludeError(FatalIncludeError): ...
+
+else:
+    def include(elem: Element, loader: Callable[..., str | Element] | None = None) -> None: ...

mypy/typeshed/stdlib/xml/etree/ElementPath.pyi

@@ -0,0 +1,34 @@
+from collections.abc import Callable, Generator
+from re import Pattern
+from typing import TypeVar
+from typing_extensions import TypeAlias
+from xml.etree.ElementTree import Element
+
+xpath_tokenizer_re: Pattern[str]
+
+_Token: TypeAlias = tuple[str, str]
+_Next: TypeAlias = Callable[[], _Token]
+_Callback: TypeAlias = Callable[[_SelectorContext, list[Element]], Generator[Element, None, None]]
+
+def xpath_tokenizer(pattern: str, namespaces: dict[str, str] | None = None) -> 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] | None
+    root: Element
+    def __init__(self, root: Element) -> None: ...
+
+_T = TypeVar("_T")
+
+def iterfind(elem: Element, path: str, namespaces: dict[str, str] | None = None) -> Generator[Element, None, None]: ...
+def find(elem: Element, path: str, namespaces: dict[str, str] | None = None) -> Element | None: ...
+def findall(elem: Element, path: str, namespaces: dict[str, str] | None = None) -> list[Element]: ...
+def findtext(elem: Element, path: str, default: _T | None = None, namespaces: dict[str, str] | None = None) -> _T | str: ...