layermap 0.1.0

package/analyzers/project-map-python/typeshed/stdlib/xml/dom/pulldom.pyi

@@ -0,0 +1,109 @@
+import sys
+from _typeshed import Incomplete, Unused
+from collections.abc import MutableSequence, Sequence
+from typing import Final, Literal, NoReturn, TypeAlias
+from typing_extensions import Self
+from xml.dom.minidom import Comment, Document, DOMImplementation, Element, ProcessingInstruction, Text
+from xml.sax import _SupportsReadClose
+from xml.sax.handler import ContentHandler
+from xml.sax.xmlreader import AttributesImpl, AttributesNSImpl, Locator, XMLReader
+
+START_ELEMENT: Final = "START_ELEMENT"
+END_ELEMENT: Final = "END_ELEMENT"
+COMMENT: Final = "COMMENT"
+START_DOCUMENT: Final = "START_DOCUMENT"
+END_DOCUMENT: Final = "END_DOCUMENT"
+PROCESSING_INSTRUCTION: Final = "PROCESSING_INSTRUCTION"
+IGNORABLE_WHITESPACE: Final = "IGNORABLE_WHITESPACE"
+CHARACTERS: Final = "CHARACTERS"
+
+_NSName: TypeAlias = tuple[str | None, str]
+_DocumentFactory: TypeAlias = DOMImplementation | None
+
+_Event: TypeAlias = (
+    tuple[Literal["START_ELEMENT"], Element]
+    | tuple[Literal["END_ELEMENT"], Element]
+    | tuple[Literal["COMMENT"], Comment]
+    | tuple[Literal["START_DOCUMENT"], Document]
+    | tuple[Literal["END_DOCUMENT"], Document]
+    | tuple[Literal["PROCESSING_INSTRUCTION"], ProcessingInstruction]
+    | tuple[Literal["IGNORABLE_WHITESPACE"], Text]
+    | tuple[Literal["CHARACTERS"], Text]
+)
+
+class PullDOM(ContentHandler):
+    document: Document | None
+    documentFactory: _DocumentFactory
+
+    # firstEvent is a list of length 2
+    # firstEvent[0] is always None
+    # firstEvent[1] is None prior to any events, after which it's a
+    # list of length 2, where the first item is of type _Event
+    # and the second item is None.
+    firstEvent: list[Incomplete]
+
+    # lastEvent is also a list of length 2. The second item is always None,
+    # and the first item is of type _Event
+    # This is a slight lie: The second item is sometimes temporarily what was just
+    # described for the type of lastEvent, after which lastEvent is always updated
+    # with `self.lastEvent = self.lastEvent[1]`.
+    lastEvent: list[Incomplete]
+
+    elementStack: MutableSequence[Element | Document]
+    pending_events: (
+        list[Sequence[tuple[Literal["COMMENT"], str] | tuple[Literal["PROCESSING_INSTRUCTION"], str, str] | None]] | None
+    )
+    def __init__(self, documentFactory: _DocumentFactory = None) -> None: ...
+    def pop(self) -> Element | Document: ...
+    def setDocumentLocator(self, locator: Locator) -> None: ...
+    def startPrefixMapping(self, prefix: str | None, uri: str) -> None: ...
+    def endPrefixMapping(self, prefix: str | None) -> None: ...
+    def startElementNS(self, name: _NSName, tagName: str | None, attrs: AttributesNSImpl) -> None: ...
+    def endElementNS(self, name: _NSName, tagName: str | None) -> None: ...
+    def startElement(self, name: str, attrs: AttributesImpl) -> None: ...
+    def endElement(self, name: str) -> None: ...
+    def comment(self, s: str) -> None: ...
+    def processingInstruction(self, target: str, data: str) -> None: ...
+    def ignorableWhitespace(self, chars: str) -> None: ...
+    def characters(self, chars: str) -> None: ...
+    def startDocument(self) -> None: ...
+    def buildDocument(self, uri: str | None, tagname: str | None) -> Element: ...
+    def endDocument(self) -> None: ...
+    def clear(self) -> None: ...
+
+class ErrorHandler:
+    def warning(self, exception: BaseException) -> None: ...
+    def error(self, exception: BaseException) -> NoReturn: ...
+    def fatalError(self, exception: BaseException) -> NoReturn: ...
+
+class DOMEventStream:
+    stream: _SupportsReadClose[bytes] | _SupportsReadClose[str]
+    parser: XMLReader  # Set to none after .clear() is called
+    bufsize: int
+    pulldom: PullDOM
+    def __init__(self, stream: _SupportsReadClose[bytes] | _SupportsReadClose[str], parser: XMLReader, bufsize: int) -> None: ...
+    if sys.version_info < (3, 11):
+        def __getitem__(self, pos: Unused) -> _Event: ...
+
+    def __next__(self) -> _Event: ...
+    def __iter__(self) -> Self: ...
+    def getEvent(self) -> _Event | None: ...
+    def expandNode(self, node: Document) -> None: ...
+    def reset(self) -> None: ...
+    def clear(self) -> None: ...
+
+class SAX2DOM(PullDOM):
+    def startElementNS(self, name: _NSName, tagName: str | None, attrs: AttributesNSImpl) -> None: ...
+    def startElement(self, name: str, attrs: AttributesImpl) -> None: ...
+    def processingInstruction(self, target: str, data: str) -> None: ...
+    def ignorableWhitespace(self, chars: str) -> None: ...
+    def characters(self, chars: str) -> None: ...
+
+default_bufsize: Final[int]
+
+def parse(
+    stream_or_string: str | _SupportsReadClose[bytes] | _SupportsReadClose[str],
+    parser: XMLReader | None = None,
+    bufsize: int | None = None,
+) -> DOMEventStream: ...
+def parseString(string: str, parser: XMLReader | None = None) -> DOMEventStream: ...

package/analyzers/project-map-python/typeshed/stdlib/xml/dom/xmlbuilder.pyi

@@ -0,0 +1,81 @@
+from _typeshed import SupportsRead
+from typing import Any, Final, Literal, NoReturn
+from xml.dom.minidom import Document, Node, _DOMErrorHandler
+
+__all__ = ["DOMBuilder", "DOMEntityResolver", "DOMInputSource"]
+
+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: _DOMErrorHandler | None
+    filter: DOMBuilderFilter | None
+
+class DOMBuilder:
+    entityResolver: DOMEntityResolver | None
+    errorHandler: _DOMErrorHandler | None
+    filter: DOMBuilderFilter | None
+    ACTION_REPLACE: Final = 1
+    ACTION_APPEND_AS_CHILDREN: Final = 2
+    ACTION_INSERT_AFTER: Final = 3
+    ACTION_INSERT_BEFORE: Final = 4
+    def __init__(self) -> None: ...
+    def setFeature(self, name: str, state: int) -> None: ...
+    def supportsFeature(self, name: str) -> bool: ...
+    def canSetFeature(self, name: str, state: Literal[1, 0]) -> bool: ...
+    # getFeature could return any attribute from an instance of `Options`
+    def getFeature(self, name: str) -> Any: ...
+    def parseURI(self, uri: str) -> Document: ...
+    def parse(self, input: DOMInputSource) -> Document: ...
+    def parseWithContext(self, input: DOMInputSource, cnode: Node, action: Literal[1, 2, 3, 4]) -> NoReturn: ...
+
+class DOMEntityResolver:
+    __slots__ = ("_opener",)
+    def resolveEntity(self, publicId: str | None, systemId: str) -> DOMInputSource: ...
+
+class DOMInputSource:
+    __slots__ = ("byteStream", "characterStream", "stringData", "encoding", "publicId", "systemId", "baseURI")
+    byteStream: SupportsRead[bytes] | None
+    characterStream: SupportsRead[str] | None
+    stringData: str | None
+    encoding: str | None
+    publicId: str | None
+    systemId: str | None
+    baseURI: str | None
+
+class DOMBuilderFilter:
+    FILTER_ACCEPT: Final = 1
+    FILTER_REJECT: Final = 2
+    FILTER_SKIP: Final = 3
+    FILTER_INTERRUPT: Final = 4
+    whatToShow: int
+    def acceptNode(self, element: Node) -> Literal[1, 2, 3, 4]: ...
+    def startContainer(self, element: Node) -> Literal[1, 2, 3, 4]: ...
+
+class DocumentLS:
+    async_: bool
+    def abort(self) -> NoReturn: ...
+    def load(self, uri: str) -> NoReturn: ...
+    def loadXML(self, source: str) -> NoReturn: ...
+    def saveXML(self, snode: Node | None) -> str: ...
+
+class DOMImplementationLS:
+    MODE_SYNCHRONOUS: Final = 1
+    MODE_ASYNCHRONOUS: Final = 2
+    def createDOMBuilder(self, mode: Literal[1], schemaType: None) -> DOMBuilder: ...
+    def createDOMWriter(self) -> NoReturn: ...
+    def createDOMInputSource(self) -> DOMInputSource: ...

package/analyzers/project-map-python/typeshed/stdlib/xml/etree/ElementInclude.pyi

@@ -0,0 +1,28 @@
+from _typeshed import FileDescriptorOrPath
+from typing import Final, Literal, Protocol, overload, type_check_only
+from xml.etree.ElementTree import Element
+
+@type_check_only
+class _Loader(Protocol):
+    @overload
+    def __call__(self, href: FileDescriptorOrPath, parse: Literal["xml"], encoding: str | None = None) -> Element: ...
+    @overload
+    def __call__(self, href: FileDescriptorOrPath, parse: Literal["text"], encoding: str | None = None) -> str: ...
+
+XINCLUDE: Final = "{http://www.w3.org/2001/XInclude}"
+
+XINCLUDE_INCLUDE: Final = "{http://www.w3.org/2001/XInclude}include"
+XINCLUDE_FALLBACK: Final = "{http://www.w3.org/2001/XInclude}fallback"
+
+DEFAULT_MAX_INCLUSION_DEPTH: Final = 6
+
+class FatalIncludeError(SyntaxError): ...
+
+@overload
+def default_loader(href: FileDescriptorOrPath, parse: Literal["xml"], encoding: str | None = None) -> Element: ...
+@overload
+def default_loader(href: FileDescriptorOrPath, parse: Literal["text"], encoding: str | None = None) -> str: ...
+
+def include(elem: Element, loader: _Loader | None = None, base_url: str | None = None, max_depth: int | None = 6) -> None: ...
+
+class LimitedRecursiveIncludeError(FatalIncludeError): ...

package/analyzers/project-map-python/typeshed/stdlib/xml/etree/ElementPath.pyi

@@ -0,0 +1,42 @@
+from collections.abc import Callable, Generator, Iterable
+from re import Pattern
+from typing import Any, Final, Literal, TypeAlias, TypeVar, overload
+from xml.etree.ElementTree import Element
+
+xpath_tokenizer_re: Final[Pattern[str]]
+
+_Token: TypeAlias = tuple[str, str]
+_Next: TypeAlias = Callable[[], _Token]
+_Callback: TypeAlias = Callable[[_SelectorContext, Iterable[Element]], Generator[Element]]
+_T = TypeVar("_T")
+
+def xpath_tokenizer(pattern: str, namespaces: dict[str, str] | None = None) -> Generator[_Token]: ...
+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 | None: ...
+def prepare_parent(next: _Next, token: _Token) -> _Callback: ...
+def prepare_predicate(next: _Next, token: _Token) -> _Callback | None: ...
+
+ops: Final[dict[str, Callable[[_Next, _Token], _Callback | None]]]
+
+class _SelectorContext:
+    parent_map: dict[Element, Element] | None
+    root: Element
+    def __init__(self, root: Element) -> None: ...
+
+@overload
+def iterfind(  # type: ignore[overload-overlap]
+    elem: Element[Any], path: Literal[""], namespaces: dict[str, str] | None = None
+) -> None: ...
+@overload
+def iterfind(elem: Element[Any], path: str, namespaces: dict[str, str] | None = None) -> Generator[Element]: ...
+
+def find(elem: Element[Any], path: str, namespaces: dict[str, str] | None = None) -> Element | None: ...
+def findall(elem: Element[Any], path: str, namespaces: dict[str, str] | None = None) -> list[Element]: ...
+
+@overload
+def findtext(elem: Element[Any], path: str, default: None = None, namespaces: dict[str, str] | None = None) -> str | None: ...
+@overload
+def findtext(elem: Element[Any], path: str, default: _T, namespaces: dict[str, str] | None = None) -> _T | str: ...

package/analyzers/project-map-python/typeshed/stdlib/xml/etree/ElementTree.pyi

@@ -0,0 +1,402 @@
+import sys
+from _collections_abc import dict_keys
+from _typeshed import FileDescriptorOrPath, ReadableBuffer, SupportsRead, SupportsWrite
+from collections.abc import Callable, Generator, ItemsView, Iterable, Iterator, Mapping, Sequence
+from typing import Any, Final, Generic, Literal, Protocol, SupportsIndex, TypeAlias, TypeGuard, TypeVar, overload, type_check_only
+from typing_extensions import deprecated, disjoint_base
+from xml.parsers.expat import XMLParserType
+
+__all__ = [
+    "C14NWriterTarget",
+    "Comment",
+    "dump",
+    "Element",
+    "ElementTree",
+    "canonicalize",
+    "fromstring",
+    "fromstringlist",
+    "indent",
+    "iselement",
+    "iterparse",
+    "parse",
+    "ParseError",
+    "PI",
+    "ProcessingInstruction",
+    "QName",
+    "SubElement",
+    "tostring",
+    "tostringlist",
+    "TreeBuilder",
+    "XML",
+    "XMLID",
+    "XMLParser",
+    "XMLPullParser",
+    "register_namespace",
+]
+if sys.version_info < (3, 15):
+    __all__ += ["VERSION"]
+
+_T = TypeVar("_T")
+_FileRead: TypeAlias = FileDescriptorOrPath | SupportsRead[bytes] | SupportsRead[str]
+_FileWriteC14N: TypeAlias = FileDescriptorOrPath | SupportsWrite[bytes]
+_FileWrite: TypeAlias = _FileWriteC14N | SupportsWrite[str]
+
+VERSION: Final[str]
+
+class ParseError(SyntaxError):
+    code: int
+    position: tuple[int, int]
+
+# In reality it works based on `.tag` attribute duck typing.
+def iselement(element: object) -> TypeGuard[Element]: ...
+
+@overload
+def canonicalize(
+    xml_data: str | ReadableBuffer | None = None,
+    *,
+    out: None = None,
+    from_file: _FileRead | None = None,
+    with_comments: bool = False,
+    strip_text: bool = False,
+    rewrite_prefixes: bool = False,
+    qname_aware_tags: Iterable[str] | None = None,
+    qname_aware_attrs: Iterable[str] | None = None,
+    exclude_attrs: Iterable[str] | None = None,
+    exclude_tags: Iterable[str] | None = None,
+) -> str: ...
+@overload
+def canonicalize(
+    xml_data: str | ReadableBuffer | None = None,
+    *,
+    out: SupportsWrite[str],
+    from_file: _FileRead | None = None,
+    with_comments: bool = False,
+    strip_text: bool = False,
+    rewrite_prefixes: bool = False,
+    qname_aware_tags: Iterable[str] | None = None,
+    qname_aware_attrs: Iterable[str] | None = None,
+    exclude_attrs: Iterable[str] | None = None,
+    exclude_tags: Iterable[str] | None = None,
+) -> None: ...
+
+# The tag for Element can be set to the Comment or ProcessingInstruction
+# functions defined in this module.
+_ElementCallable: TypeAlias = Callable[..., Element[_ElementCallable]]
+
+_Tag = TypeVar("_Tag", default=str, bound=str | _ElementCallable)
+_OtherTag = TypeVar("_OtherTag", default=str, bound=str | _ElementCallable)
+
+@disjoint_base
+class Element(Generic[_Tag]):
+    tag: _Tag
+    attrib: dict[str, str]
+    text: str | None
+    tail: str | None
+    def __init__(self, tag: _Tag, attrib: dict[str, str] = {}, **extra: str) -> None: ...
+    def append(self, subelement: Element[Any], /) -> None: ...
+    def clear(self) -> None: ...
+    def extend(self, elements: Iterable[Element[Any]], /) -> None: ...
+    def find(self, path: str, namespaces: dict[str, str] | None = None) -> Element | None: ...
+    def findall(self, path: str, namespaces: dict[str, str] | None = None) -> list[Element]: ...
+
+    @overload
+    def findtext(self, path: str, default: None = None, namespaces: dict[str, str] | None = None) -> str | None: ...
+    @overload
+    def findtext(self, path: str, default: _T, namespaces: dict[str, str] | None = None) -> _T | str: ...
+
+    @overload
+    def get(self, key: str, default: None = None) -> str | None: ...
+    @overload
+    def get(self, key: str, default: _T) -> str | _T: ...
+
+    def insert(self, index: int, subelement: Element[Any], /) -> None: ...
+    def items(self) -> ItemsView[str, str]: ...
+    def iter(self, tag: str | None = None) -> Generator[Element]: ...
+
+    @overload
+    def iterfind(self, path: Literal[""], namespaces: dict[str, str] | None = None) -> None: ...  # type: ignore[overload-overlap]
+    @overload
+    def iterfind(self, path: str, namespaces: dict[str, str] | None = None) -> Generator[Element]: ...
+
+    def itertext(self) -> Generator[str]: ...
+    def keys(self) -> dict_keys[str, str]: ...
+    # makeelement returns the type of self in Python impl, but not in C impl
+    def makeelement(self, tag: _OtherTag, attrib: dict[str, str], /) -> Element[_OtherTag]: ...
+    def remove(self, subelement: Element[Any], /) -> None: ...
+    def set(self, key: str, value: str, /) -> None: ...
+    def __copy__(self) -> Element[_Tag]: ...  # returns the type of self in Python impl, but not in C impl
+    def __deepcopy__(self, memo: Any, /) -> Element: ...  # Only exists in C impl
+    def __delitem__(self, key: SupportsIndex | slice, /) -> None: ...
+
+    @overload
+    def __getitem__(self, key: SupportsIndex, /) -> Element: ...
+    @overload
+    def __getitem__(self, key: slice[SupportsIndex | None], /) -> list[Element]: ...
+
+    def __len__(self) -> int: ...
+    # Doesn't actually exist at runtime, but instance of the class are indeed iterable due to __getitem__.
+    def __iter__(self) -> Iterator[Element]: ...
+
+    @overload
+    def __setitem__(self, key: SupportsIndex, value: Element[Any], /) -> None: ...
+    @overload
+    def __setitem__(self, key: slice[SupportsIndex | None], value: Iterable[Element[Any]], /) -> None: ...
+
+    # Doesn't really exist in earlier versions, where __len__ is called implicitly instead
+    @deprecated("Testing an element's truth value is deprecated.")
+    def __bool__(self) -> bool: ...
+
+def SubElement(parent: Element[Any], tag: str, attrib: dict[str, str] = ..., **extra: str) -> Element: ...
+def Comment(text: str | None = None) -> Element[_ElementCallable]: ...
+def ProcessingInstruction(target: str, text: str | None = None) -> Element[_ElementCallable]: ...
+
+PI = ProcessingInstruction
+
+class QName:
+    text: str
+    def __init__(self, text_or_uri: str, tag: str | None = None) -> None: ...
+    def __lt__(self, other: QName | str) -> bool: ...
+    def __le__(self, other: QName | str) -> bool: ...
+    def __gt__(self, other: QName | str) -> bool: ...
+    def __ge__(self, other: QName | str) -> bool: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+
+_Root = TypeVar("_Root", Element, Element | None, default=Element | None)
+
+class ElementTree(Generic[_Root]):
+    def __init__(self, element: Element[Any] | None = None, file: _FileRead | None = None) -> None: ...
+    def getroot(self) -> _Root: ...
+    def _setroot(self, element: Element[Any]) -> None: ...
+    def parse(self, source: _FileRead, parser: XMLParser | None = None) -> Element: ...
+    def iter(self, tag: str | None = None) -> Generator[Element]: ...
+    def find(self, path: str, namespaces: dict[str, str] | None = None) -> Element | None: ...
+
+    @overload
+    def findtext(self, path: str, default: None = None, namespaces: dict[str, str] | None = None) -> str | None: ...
+    @overload
+    def findtext(self, path: str, default: _T, namespaces: dict[str, str] | None = None) -> _T | str: ...
+
+    def findall(self, path: str, namespaces: dict[str, str] | None = None) -> list[Element]: ...
+
+    @overload
+    def iterfind(self, path: Literal[""], namespaces: dict[str, str] | None = None) -> None: ...  # type: ignore[overload-overlap]
+    @overload
+    def iterfind(self, path: str, namespaces: dict[str, str] | None = None) -> Generator[Element]: ...
+
+    def write(
+        self,
+        file_or_filename: _FileWrite,
+        encoding: str | None = None,
+        xml_declaration: bool | None = None,
+        default_namespace: str | None = None,
+        method: Literal["xml", "html", "text", "c14n"] | None = None,
+        *,
+        short_empty_elements: bool = True,
+    ) -> None: ...
+    def write_c14n(self, file: _FileWriteC14N) -> None: ...
+
+HTML_EMPTY: Final[set[str]]
+
+def register_namespace(prefix: str, uri: str) -> None: ...
+
+@overload
+def tostring(
+    element: Element[Any],
+    encoding: None = None,
+    method: Literal["xml", "html", "text", "c14n"] | None = None,
+    *,
+    xml_declaration: bool | None = None,
+    default_namespace: str | None = None,
+    short_empty_elements: bool = True,
+) -> bytes: ...
+@overload
+def tostring(
+    element: Element[Any],
+    encoding: Literal["unicode"],
+    method: Literal["xml", "html", "text", "c14n"] | None = None,
+    *,
+    xml_declaration: bool | None = None,
+    default_namespace: str | None = None,
+    short_empty_elements: bool = True,
+) -> str: ...
+@overload
+def tostring(
+    element: Element[Any],
+    encoding: str,
+    method: Literal["xml", "html", "text", "c14n"] | None = None,
+    *,
+    xml_declaration: bool | None = None,
+    default_namespace: str | None = None,
+    short_empty_elements: bool = True,
+) -> Any: ...
+
+@overload
+def tostringlist(
+    element: Element[Any],
+    encoding: None = None,
+    method: Literal["xml", "html", "text", "c14n"] | None = None,
+    *,
+    xml_declaration: bool | None = None,
+    default_namespace: str | None = None,
+    short_empty_elements: bool = True,
+) -> list[bytes]: ...
+@overload
+def tostringlist(
+    element: Element[Any],
+    encoding: Literal["unicode"],
+    method: Literal["xml", "html", "text", "c14n"] | None = None,
+    *,
+    xml_declaration: bool | None = None,
+    default_namespace: str | None = None,
+    short_empty_elements: bool = True,
+) -> list[str]: ...
+@overload
+def tostringlist(
+    element: Element[Any],
+    encoding: str,
+    method: Literal["xml", "html", "text", "c14n"] | None = None,
+    *,
+    xml_declaration: bool | None = None,
+    default_namespace: str | None = None,
+    short_empty_elements: bool = True,
+) -> list[Any]: ...
+
+def dump(elem: Element[Any] | ElementTree[Any]) -> None: ...
+def indent(tree: Element[Any] | ElementTree[Any], space: str = "  ", level: int = 0) -> None: ...
+def parse(source: _FileRead, parser: XMLParser[Any] | None = None) -> ElementTree[Element]: ...
+
+# The type of the second element of the tuple yielded by iterparse depends
+# on the event type in the first element of the tuple:
+#  * start, end: Element[str]
+#  * comment, pi: Element[_ElementCallable]
+#  * start-ns: tuple[str, str] (prefix, uri)
+#  * end-ns: None
+_EventT_co = TypeVar("_EventT_co", bound=Element[str] | Element[_ElementCallable] | tuple[str, str] | None, covariant=True)
+_EventType: TypeAlias = Literal["start", "end", "comment", "pi", "start-ns", "end-ns"]
+
+# This class is defined inside the body of iterparse.
+@type_check_only
+class _IterParseIterator(Iterator[tuple[_EventType, _EventT_co]], Protocol[_EventT_co]):
+    if sys.version_info >= (3, 13):
+        def close(self) -> None: ...
+    if sys.version_info >= (3, 11):
+        def __del__(self) -> None: ...
+
+# See the comment for _EventT_co above for possible iterator types.
+@overload
+def iterparse(source: _FileRead, events: Iterable[_EventType]) -> _IterParseIterator[Any]: ...
+@overload
+def iterparse(source: _FileRead, events: None = None) -> _IterParseIterator[Element[str]]: ...
+
+# In case a custom parser is passed, the type of the second element of the tuple
+# yielded by iterparse depends on the parser.
+@overload
+@deprecated("The `parser` parameter is deprecated since Python 3.4.")
+def iterparse(source: _FileRead, events: Iterable[_EventType], parser: XMLParser | None = None) -> _IterParseIterator[Any]: ...
+
+_EventQueue: TypeAlias = tuple[str] | tuple[str, tuple[str, str]] | tuple[str, None]
+
+class XMLPullParser(Generic[_EventT_co]):
+    def __init__(self, events: Iterable[_EventType] | None = None, *, _parser: XMLParser[_EventT_co] | None = None) -> None: ...
+    def feed(self, data: str | ReadableBuffer) -> None: ...
+    def close(self) -> None: ...
+    def read_events(self) -> Iterator[_EventQueue | tuple[_EventType, _EventT_co]]: ...
+    def flush(self) -> None: ...
+
+def XML(text: str | ReadableBuffer, parser: XMLParser | None = None) -> Element: ...
+def XMLID(text: str | ReadableBuffer, parser: XMLParser | None = None) -> tuple[Element, dict[str, Element]]: ...
+
+# This is aliased to XML in the source.
+fromstring = XML
+
+def fromstringlist(sequence: Sequence[str | ReadableBuffer], parser: XMLParser | None = None) -> 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: TypeAlias = Callable[[Any, dict[Any, Any]], Element]
+
+@disjoint_base
+class TreeBuilder:
+    # comment_factory can take None because passing None to Comment is not an error
+    def __init__(
+        self,
+        element_factory: _ElementFactory | None = None,
+        *,
+        comment_factory: Callable[[str | None], Element[Any]] | None = None,
+        pi_factory: Callable[[str, str | None], Element[Any]] | None = None,
+        insert_comments: bool = False,
+        insert_pis: bool = False,
+    ) -> None: ...
+    insert_comments: bool
+    insert_pis: bool
+
+    def close(self) -> Element: ...
+    def data(self, data: str, /) -> None: ...
+    # tag and attrs are passed to the element_factory, so they could be anything
+    # depending on what the particular factory supports.
+    def start(self, tag: Any, attrs: dict[Any, Any], /) -> Element: ...
+    def end(self, tag: str, /) -> Element: ...
+    # These two methods have pos-only parameters in the C implementation
+    def comment(self, text: str | None, /) -> Element[Any]: ...
+    def pi(self, target: str, text: str | None = None, /) -> Element[Any]: ...
+
+class C14NWriterTarget:
+    def __init__(
+        self,
+        write: Callable[[str], object],
+        *,
+        with_comments: bool = False,
+        strip_text: bool = False,
+        rewrite_prefixes: bool = False,
+        qname_aware_tags: Iterable[str] | None = None,
+        qname_aware_attrs: Iterable[str] | None = None,
+        exclude_attrs: Iterable[str] | None = None,
+        exclude_tags: Iterable[str] | None = None,
+    ) -> None: ...
+    def data(self, data: str) -> None: ...
+    def start_ns(self, prefix: str, uri: str) -> None: ...
+    def start(self, tag: str, attrs: Mapping[str, str]) -> None: ...
+    def end(self, tag: str) -> None: ...
+    def comment(self, text: str) -> None: ...
+    def pi(self, target: str, data: str) -> None: ...
+
+# The target type is tricky, because the implementation doesn't
+# require any particular attribute to be present. This documents the attributes
+# that can be present, but uncommenting any of them would require them.
+@type_check_only
+class _Target(Protocol):
+    # start: Callable[str, dict[str, str], Any] | None
+    # end: Callable[[str], Any] | None
+    # start_ns: Callable[[str, str], Any] | None
+    # end_ns: Callable[[str], Any] | None
+    # data: Callable[[str], Any] | None
+    # comment: Callable[[str], Any]
+    # pi: Callable[[str, str], Any] | None
+    # close: Callable[[], Any] | None
+    ...
+
+_E = TypeVar("_E", default=Element)
+
+# This is generic because the return type of close() depends on the target.
+# The default target is TreeBuilder, which returns Element.
+# C14NWriterTarget does not implement a close method, so using it results
+# in a type of XMLParser[None].
+@disjoint_base
+class XMLParser(Generic[_E]):
+    parser: XMLParserType
+    target: _Target
+    # TODO: what is entity used for???
+    entity: dict[str, str]
+    version: str
+    def __init__(self, *, target: _Target | None = None, encoding: str | None = None) -> None: ...
+    def close(self) -> _E: ...
+    def feed(self, data: str | ReadableBuffer, /) -> None: ...
+    def flush(self) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/xml/etree/cElementTree.pyi

@@ -0,0 +1 @@
+from xml.etree.ElementTree import *

package/analyzers/project-map-python/typeshed/stdlib/xml/parsers/__init__.pyi

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

package/analyzers/project-map-python/typeshed/stdlib/xml/parsers/expat/__init__.pyi

@@ -0,0 +1,7 @@
+from pyexpat import *
+
+# This is actually implemented in the C module pyexpat, but considers itself to live here.
+class ExpatError(Exception):
+    code: int
+    lineno: int
+    offset: int

package/analyzers/project-map-python/typeshed/stdlib/xml/parsers/expat/errors.pyi

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