jaclang 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

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

@@ -0,0 +1,35 @@
+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: ...

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

@@ -0,0 +1,49 @@
+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: ...

jaclang/vendor/mypy/typeshed/stdlib/xml/etree/ElementTree.pyi

@@ -0,0 +1,367 @@
+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, Literal, SupportsIndex, TypeVar, overload
+from typing_extensions import TypeAlias, TypeGuard
+
+__all__ = [
+    "C14NWriterTarget",
+    "Comment",
+    "dump",
+    "Element",
+    "ElementTree",
+    "canonicalize",
+    "fromstring",
+    "fromstringlist",
+    "iselement",
+    "iterparse",
+    "parse",
+    "ParseError",
+    "PI",
+    "ProcessingInstruction",
+    "QName",
+    "SubElement",
+    "tostring",
+    "tostringlist",
+    "TreeBuilder",
+    "VERSION",
+    "XML",
+    "XMLID",
+    "XMLParser",
+    "XMLPullParser",
+    "register_namespace",
+]
+
+if sys.version_info >= (3, 9):
+    __all__ += ["indent"]
+
+_T = TypeVar("_T")
+_FileRead: TypeAlias = FileDescriptorOrPath | SupportsRead[bytes] | SupportsRead[str]
+_FileWriteC14N: TypeAlias = FileDescriptorOrPath | SupportsWrite[bytes]
+_FileWrite: TypeAlias = _FileWriteC14N | SupportsWrite[str]
+
+VERSION: 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: ...
+
+class Element:
+    tag: str
+    attrib: dict[str, str]
+    text: str | None
+    tail: str | None
+    def __init__(
+        self, tag: str, attrib: dict[str, str] = ..., **extra: str
+    ) -> None: ...
+    def append(self, __subelement: Element) -> None: ...
+    def clear(self) -> None: ...
+    def extend(self, __elements: Iterable[Element]) -> 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) -> None: ...
+    def items(self) -> ItemsView[str, str]: ...
+    def iter(self, tag: str | None = None) -> Generator[Element, None, None]: ...
+    def iterfind(
+        self, path: str, namespaces: dict[str, str] | None = None
+    ) -> Generator[Element, None, None]: ...
+    def itertext(self) -> Generator[str, None, None]: ...
+    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: str, __attrib: dict[str, str]) -> Element: ...
+    def remove(self, __subelement: Element) -> None: ...
+    def set(self, __key: str, __value: str) -> None: ...
+    def __copy__(
+        self,
+    ) -> Element: ...  # 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) -> 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) -> None: ...
+    @overload
+    def __setitem__(self, __key: slice, __value: Iterable[Element]) -> None: ...
+    if sys.version_info < (3, 9):
+        def getchildren(self) -> list[Element]: ...
+        def getiterator(self, tag: str | None = None) -> list[Element]: ...
+
+def SubElement(
+    parent: Element, tag: str, attrib: dict[str, str] = ..., **extra: str
+) -> Element: ...
+def Comment(text: str | None = None) -> Element: ...
+def ProcessingInstruction(target: str, text: str | None = None) -> Element: ...
+
+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: ...
+
+class ElementTree:
+    def __init__(
+        self, element: Element | None = None, file: _FileRead | None = None
+    ) -> None: ...
+    def getroot(self) -> Element | Any: ...
+    def parse(self, source: _FileRead, parser: XMLParser | None = None) -> Element: ...
+    def iter(self, tag: str | None = None) -> Generator[Element, None, None]: ...
+    if sys.version_info < (3, 9):
+        def getiterator(self, tag: str | None = None) -> list[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]: ...
+    def iterfind(
+        self, path: str, namespaces: dict[str, str] | None = None
+    ) -> Generator[Element, None, None]: ...
+    def write(
+        self,
+        file_or_filename: _FileWrite,
+        encoding: str | None = None,
+        xml_declaration: bool | None = None,
+        default_namespace: str | None = None,
+        method: str | None = None,
+        *,
+        short_empty_elements: bool = True,
+    ) -> None: ...
+    def write_c14n(self, file: _FileWriteC14N) -> None: ...
+
+def register_namespace(prefix: str, uri: str) -> None: ...
+@overload
+def tostring(
+    element: Element,
+    encoding: None = None,
+    method: str | None = None,
+    *,
+    xml_declaration: bool | None = None,
+    default_namespace: str | None = None,
+    short_empty_elements: bool = True,
+) -> bytes: ...
+@overload
+def tostring(
+    element: Element,
+    encoding: Literal["unicode"],
+    method: str | None = None,
+    *,
+    xml_declaration: bool | None = None,
+    default_namespace: str | None = None,
+    short_empty_elements: bool = True,
+) -> str: ...
+@overload
+def tostring(
+    element: Element,
+    encoding: str,
+    method: str | None = None,
+    *,
+    xml_declaration: bool | None = None,
+    default_namespace: str | None = None,
+    short_empty_elements: bool = True,
+) -> Any: ...
+@overload
+def tostringlist(
+    element: Element,
+    encoding: None = None,
+    method: str | None = None,
+    *,
+    xml_declaration: bool | None = None,
+    default_namespace: str | None = None,
+    short_empty_elements: bool = True,
+) -> list[bytes]: ...
+@overload
+def tostringlist(
+    element: Element,
+    encoding: Literal["unicode"],
+    method: str | None = None,
+    *,
+    xml_declaration: bool | None = None,
+    default_namespace: str | None = None,
+    short_empty_elements: bool = True,
+) -> list[str]: ...
+@overload
+def tostringlist(
+    element: Element,
+    encoding: str,
+    method: str | None = None,
+    *,
+    xml_declaration: bool | None = None,
+    default_namespace: str | None = None,
+    short_empty_elements: bool = True,
+) -> list[Any]: ...
+def dump(elem: Element) -> None: ...
+
+if sys.version_info >= (3, 9):
+    def indent(
+        tree: Element | ElementTree, space: str = "  ", level: int = 0
+    ) -> None: ...
+
+def parse(source: _FileRead, parser: XMLParser | None = None) -> ElementTree: ...
+def iterparse(
+    source: _FileRead,
+    events: Sequence[str] | None = None,
+    parser: XMLParser | None = None,
+) -> Iterator[tuple[str, Any]]: ...
+
+class XMLPullParser:
+    def __init__(
+        self, events: Sequence[str] | None = None, *, _parser: XMLParser | None = None
+    ) -> None: ...
+    def feed(self, data: str | ReadableBuffer) -> None: ...
+    def close(self) -> None: ...
+    # Second element in the tuple could be `Element`, `tuple[str, str]` or `None`.
+    # Use `Any` to avoid false-positive errors.
+    def read_events(self) -> Iterator[tuple[str, Any]]: ...
+
+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]
+
+class TreeBuilder:
+    # comment_factory can take None because passing None to Comment is not an error
+    def __init__(
+        self,
+        element_factory: _ElementFactory | None = ...,
+        *,
+        comment_factory: Callable[[str | None], Element] | None = ...,
+        pi_factory: Callable[[str, str | None], Element] | None = ...,
+        insert_comments: bool = ...,
+        insert_pis: bool = ...,
+    ) -> 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: ...
+    def pi(self, __target: str, __text: str | None = None) -> Element: ...
+
+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: ...
+
+class XMLParser:
+    parser: Any
+    target: Any
+    # TODO-what is entity used for???
+    entity: Any
+    version: str
+    def __init__(self, *, target: Any = ..., encoding: str | None = ...) -> None: ...
+    def close(self) -> Any: ...
+    def feed(self, __data: str | ReadableBuffer) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/xml/etree/cElementTree.pyi

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

jaclang/vendor/mypy/typeshed/stdlib/xml/parsers/__init__.pyi

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

jaclang/vendor/mypy/typeshed/stdlib/xml/parsers/expat/__init__.pyi

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

jaclang/vendor/mypy/typeshed/stdlib/xml/parsers/expat/errors.pyi

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

jaclang/vendor/mypy/typeshed/stdlib/xml/parsers/expat/model.pyi

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

jaclang/vendor/mypy/typeshed/stdlib/xml/sax/__init__.pyi

@@ -0,0 +1,34 @@
+from _typeshed import ReadableBuffer, StrPath, SupportsRead, _T_co
+from collections.abc import Iterable
+from typing import Protocol
+from typing_extensions import TypeAlias
+from xml.sax._exceptions import (
+    SAXException as SAXException,
+    SAXNotRecognizedException as SAXNotRecognizedException,
+    SAXNotSupportedException as SAXNotSupportedException,
+    SAXParseException as SAXParseException,
+    SAXReaderNotAvailable as SAXReaderNotAvailable,
+)
+from xml.sax.handler import (
+    ContentHandler as ContentHandler,
+    ErrorHandler as ErrorHandler,
+)
+from xml.sax.xmlreader import XMLReader
+
+class _SupportsReadClose(SupportsRead[_T_co], Protocol[_T_co]):
+    def close(self) -> None: ...
+
+_Source: TypeAlias = StrPath | _SupportsReadClose[bytes] | _SupportsReadClose[str]
+
+default_parser_list: list[str]
+
+def make_parser(parser_list: Iterable[str] = ()) -> XMLReader: ...
+def parse(
+    source: _Source, handler: ContentHandler, errorHandler: ErrorHandler = ...
+) -> None: ...
+def parseString(
+    string: ReadableBuffer | str,
+    handler: ContentHandler,
+    errorHandler: ErrorHandler | None = ...,
+) -> None: ...
+def _create_parser(parser_name: str) -> XMLReader: ...

jaclang/vendor/mypy/typeshed/stdlib/xml/sax/_exceptions.pyi

@@ -0,0 +1,21 @@
+from typing import NoReturn
+from xml.sax.xmlreader import Locator
+
+class SAXException(Exception):
+    def __init__(self, msg: str, exception: Exception | None = None) -> None: ...
+    def getMessage(self) -> str: ...
+    def getException(self) -> Exception: ...
+    def __getitem__(self, ix: object) -> NoReturn: ...
+
+class SAXParseException(SAXException):
+    def __init__(
+        self, msg: str, exception: Exception | None, 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): ...

jaclang/vendor/mypy/typeshed/stdlib/xml/sax/handler.pyi

@@ -0,0 +1,59 @@
+import sys
+from typing import NoReturn
+from xml.sax import xmlreader
+
+version: str
+
+class ErrorHandler:
+    def error(self, exception: BaseException) -> NoReturn: ...
+    def fatalError(self, exception: BaseException) -> NoReturn: ...
+    def warning(self, exception: BaseException) -> None: ...
+
+class ContentHandler:
+    def setDocumentLocator(self, locator: xmlreader.Locator) -> None: ...
+    def startDocument(self) -> None: ...
+    def endDocument(self) -> None: ...
+    def startPrefixMapping(self, prefix: str | None, uri: str) -> None: ...
+    def endPrefixMapping(self, prefix) -> None: ...
+    def startElement(self, name: str, attrs: xmlreader.AttributesImpl) -> None: ...
+    def endElement(self, name: str) -> None: ...
+    def startElementNS(
+        self, name: tuple[str, str], qname: str, attrs: xmlreader.AttributesNSImpl
+    ) -> None: ...
+    def endElementNS(self, name: tuple[str, str], qname: str) -> None: ...
+    def characters(self, content: str) -> None: ...
+    def ignorableWhitespace(self, whitespace: str) -> None: ...
+    def processingInstruction(self, target: str, data: str) -> None: ...
+    def skippedEntity(self, name: str) -> None: ...
+
+class DTDHandler:
+    def notationDecl(self, name, publicId, systemId): ...
+    def unparsedEntityDecl(self, name, publicId, systemId, ndata): ...
+
+class EntityResolver:
+    def resolveEntity(self, publicId, systemId): ...
+
+feature_namespaces: str
+feature_namespace_prefixes: str
+feature_string_interning: str
+feature_validation: str
+feature_external_ges: str
+feature_external_pes: str
+all_features: list[str]
+property_lexical_handler: str
+property_declaration_handler: str
+property_dom_node: str
+property_xml_string: str
+property_encoding: str
+property_interning_dict: str
+all_properties: list[str]
+
+if sys.version_info >= (3, 10):
+    class LexicalHandler:
+        def comment(self, content: str) -> object: ...
+        def startDTD(
+            self, name: str, public_id: str | None, system_id: str | None
+        ) -> object: ...
+        def endDTD(self) -> object: ...
+        def startCDATA(self) -> object: ...
+        def endCDATA(self) -> object: ...

jaclang/vendor/mypy/typeshed/stdlib/xml/sax/saxutils.pyi

@@ -0,0 +1,71 @@
+from _typeshed import SupportsWrite
+from codecs import StreamReaderWriter, StreamWriter
+from collections.abc import Mapping
+from io import RawIOBase, TextIOBase
+from xml.sax import _Source, handler, xmlreader
+
+def escape(data: str, entities: Mapping[str, str] = {}) -> str: ...
+def unescape(data: str, entities: Mapping[str, str] = {}) -> str: ...
+def quoteattr(data: str, entities: Mapping[str, str] = {}) -> str: ...
+
+class XMLGenerator(handler.ContentHandler):
+    def __init__(
+        self,
+        out: (
+            TextIOBase
+            | RawIOBase
+            | StreamWriter
+            | StreamReaderWriter
+            | SupportsWrite[bytes]
+            | None
+        ) = None,
+        encoding: str = "iso-8859-1",
+        short_empty_elements: bool = False,
+    ) -> None: ...
+    def startDocument(self) -> None: ...
+    def endDocument(self) -> None: ...
+    def startPrefixMapping(self, prefix: str | None, uri: str) -> None: ...
+    def endPrefixMapping(self, prefix: str | None) -> None: ...
+    def startElement(self, name: str, attrs: xmlreader.AttributesImpl) -> None: ...
+    def endElement(self, name: str) -> None: ...
+    def startElementNS(
+        self, name: tuple[str, str], qname: str, attrs: xmlreader.AttributesNSImpl
+    ) -> None: ...
+    def endElementNS(self, name: tuple[str, str], qname: str) -> None: ...
+    def characters(self, content: str) -> None: ...
+    def ignorableWhitespace(self, content: str) -> None: ...
+    def processingInstruction(self, target: str, data: str) -> None: ...
+
+class XMLFilterBase(xmlreader.XMLReader):
+    def __init__(self, parent: xmlreader.XMLReader | None = None) -> None: ...
+    def error(self, exception): ...
+    def fatalError(self, exception): ...
+    def warning(self, exception): ...
+    def setDocumentLocator(self, locator: xmlreader.Locator) -> None: ...
+    def startDocument(self) -> None: ...
+    def endDocument(self) -> None: ...
+    def startPrefixMapping(self, prefix: str | None, uri: str) -> None: ...
+    def endPrefixMapping(self, prefix: str | None) -> None: ...
+    def startElement(self, name: str, attrs: xmlreader.AttributesImpl) -> None: ...
+    def endElement(self, name: str) -> None: ...
+    def startElementNS(
+        self, name: tuple[str, str], qname: str, attrs: xmlreader.AttributesNSImpl
+    ) -> None: ...
+    def endElementNS(self, name: tuple[str, str], qname: str) -> None: ...
+    def characters(self, content: str) -> None: ...
+    def ignorableWhitespace(self, chars: str) -> None: ...
+    def processingInstruction(self, target: str, data: str) -> None: ...
+    def skippedEntity(self, name: str) -> None: ...
+    def notationDecl(self, name, publicId, systemId): ...
+    def unparsedEntityDecl(self, name, publicId, systemId, ndata): ...
+    def resolveEntity(self, publicId, systemId): ...
+    def parse(self, source: _Source) -> None: ...
+    def setLocale(self, locale): ...
+    def getFeature(self, name: str) -> object: ...
+    def setFeature(self, name: str, state: object) -> None: ...
+    def getProperty(self, name: str) -> object: ...
+    def setProperty(self, name: str, value: object) -> None: ...
+    def getParent(self) -> xmlreader.XMLReader: ...
+    def setParent(self, parent: xmlreader.XMLReader) -> None: ...
+
+def prepare_input_source(source, base=""): ...