basedpyright 1.1.389 → 1.1.392

package/dist/typeshed-fallback/stdlib/xml/dom/pulldom.pyi

@@ -1,94 +1,94 @@
-import sys
-from _typeshed import Incomplete, SupportsRead
-from collections.abc import Sequence
-from typing import Final, 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: 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"
-
-_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: ...
+import sys
+from _typeshed import Incomplete, SupportsRead
+from collections.abc import Sequence
+from typing import Final, 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: 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"
+
+_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: ...

package/dist/typeshed-fallback/stdlib/xml/dom/xmlbuilder.pyi

@@ -1,108 +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) -> Any: ...
-    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: ...
+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) -> Any: ...
+    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: ...

package/dist/typeshed-fallback/stdlib/xml/etree/ElementInclude.pyi

@@ -1,29 +1,29 @@
-import sys
-from _typeshed import FileDescriptorOrPath
-from collections.abc import Callable
-from typing import Final
-from xml.etree.ElementTree import Element
-
-XINCLUDE: Final[str]
-XINCLUDE_INCLUDE: Final[str]
-XINCLUDE_FALLBACK: Final[str]
-
-if sys.version_info >= (3, 9):
-    DEFAULT_MAX_INCLUSION_DEPTH: Final = 6
-
-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: ...
+import sys
+from _typeshed import FileDescriptorOrPath
+from collections.abc import Callable
+from typing import Final
+from xml.etree.ElementTree import Element
+
+XINCLUDE: Final[str]
+XINCLUDE_INCLUDE: Final[str]
+XINCLUDE_FALLBACK: Final[str]
+
+if sys.version_info >= (3, 9):
+    DEFAULT_MAX_INCLUSION_DEPTH: Final = 6
+
+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: ...

package/dist/typeshed-fallback/stdlib/xml/etree/ElementPath.pyi

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