jaclang 0.7.34__py3-none-any.whl → 0.8.1__py3-none-any.whl

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

@@ -1,404 +0,0 @@
-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: int) -> Self: ...
-    def writexml(self, writer: SupportsWrite[str], indent: str = "", addindent: str = "", newl: str = "") -> None: ...
-    def replaceWholeText(self, content) -> Self | None: ...
-    @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): ...

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

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

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

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

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

@@ -1,28 +0,0 @@
-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

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