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

mypy/typeshed/stdlib/winreg.pyi

@@ -0,0 +1,103 @@
+import sys
+from types import TracebackType
+from typing import Any, Literal, final
+from typing_extensions import Self, TypeAlias
+
+if sys.platform == "win32":
+    _KeyType: TypeAlias = HKEYType | int
+    def CloseKey(__hkey: _KeyType) -> None: ...
+    def ConnectRegistry(__computer_name: str | None, __key: _KeyType) -> HKEYType: ...
+    def CreateKey(__key: _KeyType, __sub_key: str | None) -> HKEYType: ...
+    def CreateKeyEx(key: _KeyType, sub_key: str | None, reserved: int = 0, access: int = 131078) -> HKEYType: ...
+    def DeleteKey(__key: _KeyType, __sub_key: str) -> None: ...
+    def DeleteKeyEx(key: _KeyType, sub_key: str, access: int = 256, reserved: int = 0) -> None: ...
+    def DeleteValue(__key: _KeyType, __value: str) -> None: ...
+    def EnumKey(__key: _KeyType, __index: int) -> str: ...
+    def EnumValue(__key: _KeyType, __index: int) -> tuple[str, Any, int]: ...
+    def ExpandEnvironmentStrings(__string: str) -> str: ...
+    def FlushKey(__key: _KeyType) -> None: ...
+    def LoadKey(__key: _KeyType, __sub_key: str, __file_name: str) -> None: ...
+    def OpenKey(key: _KeyType, sub_key: str, reserved: int = 0, access: int = 131097) -> HKEYType: ...
+    def OpenKeyEx(key: _KeyType, sub_key: str, reserved: int = 0, access: int = 131097) -> HKEYType: ...
+    def QueryInfoKey(__key: _KeyType) -> tuple[int, int, int]: ...
+    def QueryValue(__key: _KeyType, __sub_key: str | None) -> str: ...
+    def QueryValueEx(__key: _KeyType, __name: str) -> tuple[Any, int]: ...
+    def SaveKey(__key: _KeyType, __file_name: str) -> None: ...
+    def SetValue(__key: _KeyType, __sub_key: str, __type: int, __value: str) -> None: ...
+    def SetValueEx(
+        __key: _KeyType, __value_name: str | None, __reserved: Any, __type: int, __value: str | int
+    ) -> None: ...  # reserved is ignored
+    def DisableReflectionKey(__key: _KeyType) -> None: ...
+    def EnableReflectionKey(__key: _KeyType) -> None: ...
+    def QueryReflectionKey(__key: _KeyType) -> bool: ...
+    HKEY_CLASSES_ROOT: int
+    HKEY_CURRENT_USER: int
+    HKEY_LOCAL_MACHINE: int
+    HKEY_USERS: int
+    HKEY_PERFORMANCE_DATA: int
+    HKEY_CURRENT_CONFIG: int
+    HKEY_DYN_DATA: int
+
+    KEY_ALL_ACCESS: Literal[983103]
+    KEY_WRITE: Literal[131078]
+    KEY_READ: Literal[131097]
+    KEY_EXECUTE: Literal[131097]
+    KEY_QUERY_VALUE: Literal[1]
+    KEY_SET_VALUE: Literal[2]
+    KEY_CREATE_SUB_KEY: Literal[4]
+    KEY_ENUMERATE_SUB_KEYS: Literal[8]
+    KEY_NOTIFY: Literal[16]
+    KEY_CREATE_LINK: Literal[32]
+
+    KEY_WOW64_64KEY: Literal[256]
+    KEY_WOW64_32KEY: Literal[512]
+
+    REG_BINARY: Literal[3]
+    REG_DWORD: Literal[4]
+    REG_DWORD_LITTLE_ENDIAN: Literal[4]
+    REG_DWORD_BIG_ENDIAN: Literal[5]
+    REG_EXPAND_SZ: Literal[2]
+    REG_LINK: Literal[6]
+    REG_MULTI_SZ: Literal[7]
+    REG_NONE: Literal[0]
+    REG_QWORD: Literal[11]
+    REG_QWORD_LITTLE_ENDIAN: Literal[11]
+    REG_RESOURCE_LIST: Literal[8]
+    REG_FULL_RESOURCE_DESCRIPTOR: Literal[9]
+    REG_RESOURCE_REQUIREMENTS_LIST: Literal[10]
+    REG_SZ: Literal[1]
+
+    REG_CREATED_NEW_KEY: int  # undocumented
+    REG_LEGAL_CHANGE_FILTER: int  # undocumented
+    REG_LEGAL_OPTION: int  # undocumented
+    REG_NOTIFY_CHANGE_ATTRIBUTES: int  # undocumented
+    REG_NOTIFY_CHANGE_LAST_SET: int  # undocumented
+    REG_NOTIFY_CHANGE_NAME: int  # undocumented
+    REG_NOTIFY_CHANGE_SECURITY: int  # undocumented
+    REG_NO_LAZY_FLUSH: int  # undocumented
+    REG_OPENED_EXISTING_KEY: int  # undocumented
+    REG_OPTION_BACKUP_RESTORE: int  # undocumented
+    REG_OPTION_CREATE_LINK: int  # undocumented
+    REG_OPTION_NON_VOLATILE: int  # undocumented
+    REG_OPTION_OPEN_LINK: int  # undocumented
+    REG_OPTION_RESERVED: int  # undocumented
+    REG_OPTION_VOLATILE: int  # undocumented
+    REG_REFRESH_HIVE: int  # undocumented
+    REG_WHOLE_HIVE_VOLATILE: int  # undocumented
+
+    error = OSError
+
+    # Though this class has a __name__ of PyHKEY, it's exposed as HKEYType for some reason
+    @final
+    class HKEYType:
+        def __bool__(self) -> bool: ...
+        def __int__(self) -> int: ...
+        def __enter__(self) -> Self: ...
+        def __exit__(
+            self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None
+        ) -> bool | None: ...
+        def Close(self) -> None: ...
+        def Detach(self) -> int: ...
+        def __hash__(self) -> int: ...
+        @property
+        def handle(self) -> int: ...

mypy/typeshed/stdlib/winsound.pyi

@@ -0,0 +1,28 @@
+import sys
+from _typeshed import ReadableBuffer
+from typing import Literal, overload
+
+if sys.platform == "win32":
+    SND_APPLICATION: Literal[128]
+    SND_FILENAME: Literal[131072]
+    SND_ALIAS: Literal[65536]
+    SND_LOOP: Literal[8]
+    SND_MEMORY: Literal[4]
+    SND_PURGE: Literal[64]
+    SND_ASYNC: Literal[1]
+    SND_NODEFAULT: Literal[2]
+    SND_NOSTOP: Literal[16]
+    SND_NOWAIT: Literal[8192]
+
+    MB_ICONASTERISK: Literal[64]
+    MB_ICONEXCLAMATION: Literal[48]
+    MB_ICONHAND: Literal[16]
+    MB_ICONQUESTION: Literal[32]
+    MB_OK: Literal[0]
+    def Beep(frequency: int, duration: int) -> None: ...
+    # Can actually accept anything ORed with 4, and if not it's definitely str, but that's inexpressible
+    @overload
+    def PlaySound(sound: ReadableBuffer | None, flags: Literal[4]) -> None: ...
+    @overload
+    def PlaySound(sound: str | ReadableBuffer | None, flags: int) -> None: ...
+    def MessageBeep(type: int = 0) -> None: ...

mypy/typeshed/stdlib/wsgiref/handlers.pyi

@@ -0,0 +1,91 @@
+from _typeshed import OptExcInfo
+from _typeshed.wsgi import ErrorStream, InputStream, StartResponse, WSGIApplication, WSGIEnvironment
+from abc import abstractmethod
+from collections.abc import Callable, MutableMapping
+from typing import IO
+
+from .headers import Headers
+from .util import FileWrapper
+
+__all__ = ["BaseHandler", "SimpleHandler", "BaseCGIHandler", "CGIHandler", "IISCGIHandler", "read_environ"]
+
+def format_date_time(timestamp: float | None) -> str: ...  # undocumented
+def read_environ() -> dict[str, str]: ...
+
+class BaseHandler:
+    wsgi_version: tuple[int, int]  # undocumented
+    wsgi_multithread: bool
+    wsgi_multiprocess: bool
+    wsgi_run_once: bool
+
+    origin_server: bool
+    http_version: str
+    server_software: str | None
+
+    os_environ: MutableMapping[str, str]
+
+    wsgi_file_wrapper: type[FileWrapper] | None
+    headers_class: type[Headers]  # undocumented
+
+    traceback_limit: int | None
+    error_status: str
+    error_headers: list[tuple[str, str]]
+    error_body: bytes
+    def run(self, application: WSGIApplication) -> None: ...
+    def setup_environ(self) -> None: ...
+    def finish_response(self) -> None: ...
+    def get_scheme(self) -> str: ...
+    def set_content_length(self) -> None: ...
+    def cleanup_headers(self) -> None: ...
+    def start_response(
+        self, status: str, headers: list[tuple[str, str]], exc_info: OptExcInfo | None = None
+    ) -> Callable[[bytes], None]: ...
+    def send_preamble(self) -> None: ...
+    def write(self, data: bytes) -> None: ...
+    def sendfile(self) -> bool: ...
+    def finish_content(self) -> None: ...
+    def close(self) -> None: ...
+    def send_headers(self) -> None: ...
+    def result_is_file(self) -> bool: ...
+    def client_is_modern(self) -> bool: ...
+    def log_exception(self, exc_info: OptExcInfo) -> None: ...
+    def handle_error(self) -> None: ...
+    def error_output(self, environ: WSGIEnvironment, start_response: StartResponse) -> list[bytes]: ...
+    @abstractmethod
+    def _write(self, data: bytes) -> None: ...
+    @abstractmethod
+    def _flush(self) -> None: ...
+    @abstractmethod
+    def get_stdin(self) -> InputStream: ...
+    @abstractmethod
+    def get_stderr(self) -> ErrorStream: ...
+    @abstractmethod
+    def add_cgi_vars(self) -> None: ...
+
+class SimpleHandler(BaseHandler):
+    stdin: InputStream
+    stdout: IO[bytes]
+    stderr: ErrorStream
+    base_env: MutableMapping[str, str]
+    def __init__(
+        self,
+        stdin: InputStream,
+        stdout: IO[bytes],
+        stderr: ErrorStream,
+        environ: MutableMapping[str, str],
+        multithread: bool = True,
+        multiprocess: bool = False,
+    ) -> None: ...
+    def get_stdin(self) -> InputStream: ...
+    def get_stderr(self) -> ErrorStream: ...
+    def add_cgi_vars(self) -> None: ...
+    def _write(self, data: bytes) -> None: ...
+    def _flush(self) -> None: ...
+
+class BaseCGIHandler(SimpleHandler): ...
+
+class CGIHandler(BaseCGIHandler):
+    def __init__(self) -> None: ...
+
+class IISCGIHandler(BaseCGIHandler):
+    def __init__(self) -> None: ...

mypy/typeshed/stdlib/wsgiref/headers.pyi

@@ -0,0 +1,26 @@
+from re import Pattern
+from typing import overload
+from typing_extensions import TypeAlias
+
+_HeaderList: TypeAlias = list[tuple[str, str]]
+
+tspecials: Pattern[str]  # undocumented
+
+class Headers:
+    def __init__(self, headers: _HeaderList | None = None) -> None: ...
+    def __len__(self) -> int: ...
+    def __setitem__(self, name: str, val: str) -> None: ...
+    def __delitem__(self, name: str) -> None: ...
+    def __getitem__(self, name: str) -> str | None: ...
+    def __contains__(self, name: str) -> bool: ...
+    def get_all(self, name: str) -> list[str]: ...
+    @overload
+    def get(self, name: str, default: str) -> str: ...
+    @overload
+    def get(self, name: str, default: str | None = None) -> str | None: ...
+    def keys(self) -> list[str]: ...
+    def values(self) -> list[str]: ...
+    def items(self) -> _HeaderList: ...
+    def __bytes__(self) -> bytes: ...
+    def setdefault(self, name: str, value: str) -> str: ...
+    def add_header(self, _name: str, _value: str | None, **_params: str | None) -> None: ...

mypy/typeshed/stdlib/wsgiref/simple_server.pyi

@@ -0,0 +1,37 @@
+from _typeshed.wsgi import ErrorStream, StartResponse, WSGIApplication, WSGIEnvironment
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from typing import TypeVar, overload
+
+from .handlers import SimpleHandler
+
+__all__ = ["WSGIServer", "WSGIRequestHandler", "demo_app", "make_server"]
+
+server_version: str  # undocumented
+sys_version: str  # undocumented
+software_version: str  # undocumented
+
+class ServerHandler(SimpleHandler):  # undocumented
+    server_software: str
+
+class WSGIServer(HTTPServer):
+    application: WSGIApplication | None
+    base_environ: WSGIEnvironment  # only available after call to setup_environ()
+    def setup_environ(self) -> None: ...
+    def get_app(self) -> WSGIApplication | None: ...
+    def set_app(self, application: WSGIApplication | None) -> None: ...
+
+class WSGIRequestHandler(BaseHTTPRequestHandler):
+    server_version: str
+    def get_environ(self) -> WSGIEnvironment: ...
+    def get_stderr(self) -> ErrorStream: ...
+
+def demo_app(environ: WSGIEnvironment, start_response: StartResponse) -> list[bytes]: ...
+
+_S = TypeVar("_S", bound=WSGIServer)
+
+@overload
+def make_server(host: str, port: int, app: WSGIApplication, *, handler_class: type[WSGIRequestHandler] = ...) -> WSGIServer: ...
+@overload
+def make_server(
+    host: str, port: int, app: WSGIApplication, server_class: type[_S], handler_class: type[WSGIRequestHandler] = ...
+) -> _S: ...

mypy/typeshed/stdlib/wsgiref/types.pyi

@@ -0,0 +1,32 @@
+from collections.abc import Callable, Iterable, Iterator
+from sys import _OptExcInfo
+from typing import Any, Protocol
+from typing_extensions import TypeAlias
+
+__all__ = ["StartResponse", "WSGIEnvironment", "WSGIApplication", "InputStream", "ErrorStream", "FileWrapper"]
+
+class StartResponse(Protocol):
+    def __call__(
+        self, __status: str, __headers: list[tuple[str, str]], __exc_info: _OptExcInfo | None = ...
+    ) -> Callable[[bytes], object]: ...
+
+WSGIEnvironment: TypeAlias = dict[str, Any]
+WSGIApplication: TypeAlias = Callable[[WSGIEnvironment, StartResponse], Iterable[bytes]]
+
+class InputStream(Protocol):
+    def read(self, __size: int = ...) -> bytes: ...
+    def readline(self, __size: int = ...) -> bytes: ...
+    def readlines(self, __hint: int = ...) -> list[bytes]: ...
+    def __iter__(self) -> Iterator[bytes]: ...
+
+class ErrorStream(Protocol):
+    def flush(self) -> object: ...
+    def write(self, __s: str) -> object: ...
+    def writelines(self, __seq: list[str]) -> object: ...
+
+class _Readable(Protocol):
+    def read(self, __size: int = ...) -> bytes: ...
+    # Optional: def close(self) -> object: ...
+
+class FileWrapper(Protocol):
+    def __call__(self, __file: _Readable, __block_size: int = ...) -> Iterable[bytes]: ...

mypy/typeshed/stdlib/wsgiref/util.pyi

@@ -0,0 +1,24 @@
+import sys
+from _typeshed.wsgi import WSGIEnvironment
+from collections.abc import Callable
+from typing import IO, Any
+
+__all__ = ["FileWrapper", "guess_scheme", "application_uri", "request_uri", "shift_path_info", "setup_testing_defaults"]
+
+class FileWrapper:
+    filelike: IO[bytes]
+    blksize: int
+    close: Callable[[], None]  # only exists if filelike.close exists
+    def __init__(self, filelike: IO[bytes], blksize: int = 8192) -> None: ...
+    if sys.version_info < (3, 11):
+        def __getitem__(self, key: Any) -> bytes: ...
+
+    def __iter__(self) -> FileWrapper: ...
+    def __next__(self) -> bytes: ...
+
+def guess_scheme(environ: WSGIEnvironment) -> str: ...
+def application_uri(environ: WSGIEnvironment) -> str: ...
+def request_uri(environ: WSGIEnvironment, include_query: bool = True) -> str: ...
+def shift_path_info(environ: WSGIEnvironment) -> str | None: ...
+def setup_testing_defaults(environ: WSGIEnvironment) -> None: ...
+def is_hop_by_hop(header_name: str) -> bool: ...

mypy/typeshed/stdlib/wsgiref/validate.pyi

@@ -0,0 +1,50 @@
+from _typeshed.wsgi import ErrorStream, InputStream, WSGIApplication
+from collections.abc import Callable, Iterable, Iterator
+from typing import Any, NoReturn
+from typing_extensions import TypeAlias
+
+__all__ = ["validator"]
+
+class WSGIWarning(Warning): ...
+
+def validator(application: WSGIApplication) -> WSGIApplication: ...
+
+class InputWrapper:
+    input: InputStream
+    def __init__(self, wsgi_input: InputStream) -> None: ...
+    def read(self, size: int) -> bytes: ...
+    def readline(self, size: int = ...) -> bytes: ...
+    def readlines(self, hint: int = ...) -> bytes: ...
+    def __iter__(self) -> Iterator[bytes]: ...
+    def close(self) -> NoReturn: ...
+
+class ErrorWrapper:
+    errors: ErrorStream
+    def __init__(self, wsgi_errors: ErrorStream) -> None: ...
+    def write(self, s: str) -> None: ...
+    def flush(self) -> None: ...
+    def writelines(self, seq: Iterable[str]) -> None: ...
+    def close(self) -> NoReturn: ...
+
+_WriterCallback: TypeAlias = Callable[[bytes], Any]
+
+class WriteWrapper:
+    writer: _WriterCallback
+    def __init__(self, wsgi_writer: _WriterCallback) -> None: ...
+    def __call__(self, s: bytes) -> None: ...
+
+class PartialIteratorWrapper:
+    iterator: Iterator[bytes]
+    def __init__(self, wsgi_iterator: Iterator[bytes]) -> None: ...
+    def __iter__(self) -> IteratorWrapper: ...
+
+class IteratorWrapper:
+    original_iterator: Iterator[bytes]
+    iterator: Iterator[bytes]
+    closed: bool
+    check_start_response: bool | None
+    def __init__(self, wsgi_iterator: Iterator[bytes], check_start_response: bool | None) -> None: ...
+    def __iter__(self) -> IteratorWrapper: ...
+    def __next__(self) -> bytes: ...
+    def close(self) -> None: ...
+    def __del__(self) -> None: ...

mypy/typeshed/stdlib/xdrlib.pyi

@@ -0,0 +1,57 @@
+from collections.abc import Callable, Sequence
+from typing import TypeVar
+
+__all__ = ["Error", "Packer", "Unpacker", "ConversionError"]
+
+_T = TypeVar("_T")
+
+class Error(Exception):
+    msg: str
+    def __init__(self, msg: str) -> None: ...
+
+class ConversionError(Error): ...
+
+class Packer:
+    def reset(self) -> None: ...
+    def get_buffer(self) -> bytes: ...
+    def get_buf(self) -> bytes: ...
+    def pack_uint(self, x: int) -> None: ...
+    def pack_int(self, x: int) -> None: ...
+    def pack_enum(self, x: int) -> None: ...
+    def pack_bool(self, x: bool) -> None: ...
+    def pack_uhyper(self, x: int) -> None: ...
+    def pack_hyper(self, x: int) -> None: ...
+    def pack_float(self, x: float) -> None: ...
+    def pack_double(self, x: float) -> None: ...
+    def pack_fstring(self, n: int, s: bytes) -> None: ...
+    def pack_fopaque(self, n: int, s: bytes) -> None: ...
+    def pack_string(self, s: bytes) -> None: ...
+    def pack_opaque(self, s: bytes) -> None: ...
+    def pack_bytes(self, s: bytes) -> None: ...
+    def pack_list(self, list: Sequence[_T], pack_item: Callable[[_T], object]) -> None: ...
+    def pack_farray(self, n: int, list: Sequence[_T], pack_item: Callable[[_T], object]) -> None: ...
+    def pack_array(self, list: Sequence[_T], pack_item: Callable[[_T], object]) -> None: ...
+
+class Unpacker:
+    def __init__(self, data: bytes) -> None: ...
+    def reset(self, data: bytes) -> None: ...
+    def get_position(self) -> int: ...
+    def set_position(self, position: int) -> None: ...
+    def get_buffer(self) -> bytes: ...
+    def done(self) -> None: ...
+    def unpack_uint(self) -> int: ...
+    def unpack_int(self) -> int: ...
+    def unpack_enum(self) -> int: ...
+    def unpack_bool(self) -> bool: ...
+    def unpack_uhyper(self) -> int: ...
+    def unpack_hyper(self) -> int: ...
+    def unpack_float(self) -> float: ...
+    def unpack_double(self) -> float: ...
+    def unpack_fstring(self, n: int) -> bytes: ...
+    def unpack_fopaque(self, n: int) -> bytes: ...
+    def unpack_string(self) -> bytes: ...
+    def unpack_opaque(self) -> bytes: ...
+    def unpack_bytes(self) -> bytes: ...
+    def unpack_list(self, unpack_item: Callable[[], _T]) -> list[_T]: ...
+    def unpack_farray(self, n: int, unpack_item: Callable[[], _T]) -> list[_T]: ...
+    def unpack_array(self, unpack_item: Callable[[], _T]) -> list[_T]: ...

mypy/typeshed/stdlib/xml/__init__.pyi

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

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

@@ -0,0 +1,19 @@
+class NodeFilter:
+    FILTER_ACCEPT: int
+    FILTER_REJECT: int
+    FILTER_SKIP: int
+
+    SHOW_ALL: int
+    SHOW_ELEMENT: int
+    SHOW_ATTRIBUTE: int
+    SHOW_TEXT: int
+    SHOW_CDATA_SECTION: int
+    SHOW_ENTITY_REFERENCE: int
+    SHOW_ENTITY: int
+    SHOW_PROCESSING_INSTRUCTION: int
+    SHOW_COMMENT: int
+    SHOW_DOCUMENT: int
+    SHOW_DOCUMENT_TYPE: int
+    SHOW_DOCUMENT_FRAGMENT: int
+    SHOW_NOTATION: int
+    def acceptNode(self, node) -> int: ...

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

@@ -0,0 +1,69 @@
+from typing import Any
+
+from .domreg import getDOMImplementation as getDOMImplementation, registerDOMImplementation as registerDOMImplementation
+
+class Node:
+    ELEMENT_NODE: int
+    ATTRIBUTE_NODE: int
+    TEXT_NODE: int
+    CDATA_SECTION_NODE: int
+    ENTITY_REFERENCE_NODE: int
+    ENTITY_NODE: int
+    PROCESSING_INSTRUCTION_NODE: int
+    COMMENT_NODE: int
+    DOCUMENT_NODE: int
+    DOCUMENT_TYPE_NODE: int
+    DOCUMENT_FRAGMENT_NODE: int
+    NOTATION_NODE: int
+
+# ExceptionCode
+INDEX_SIZE_ERR: int
+DOMSTRING_SIZE_ERR: int
+HIERARCHY_REQUEST_ERR: int
+WRONG_DOCUMENT_ERR: int
+INVALID_CHARACTER_ERR: int
+NO_DATA_ALLOWED_ERR: int
+NO_MODIFICATION_ALLOWED_ERR: int
+NOT_FOUND_ERR: int
+NOT_SUPPORTED_ERR: int
+INUSE_ATTRIBUTE_ERR: int
+INVALID_STATE_ERR: int
+SYNTAX_ERR: int
+INVALID_MODIFICATION_ERR: int
+NAMESPACE_ERR: int
+INVALID_ACCESS_ERR: int
+VALIDATION_ERR: int
+
+class DOMException(Exception):
+    code: int
+    def __init__(self, *args: Any, **kw: Any) -> None: ...
+    def _get_code(self) -> int: ...
+
+class IndexSizeErr(DOMException): ...
+class DomstringSizeErr(DOMException): ...
+class HierarchyRequestErr(DOMException): ...
+class WrongDocumentErr(DOMException): ...
+class InvalidCharacterErr(DOMException): ...
+class NoDataAllowedErr(DOMException): ...
+class NoModificationAllowedErr(DOMException): ...
+class NotFoundErr(DOMException): ...
+class NotSupportedErr(DOMException): ...
+class InuseAttributeErr(DOMException): ...
+class InvalidStateErr(DOMException): ...
+class SyntaxErr(DOMException): ...
+class InvalidModificationErr(DOMException): ...
+class NamespaceErr(DOMException): ...
+class InvalidAccessErr(DOMException): ...
+class ValidationErr(DOMException): ...
+
+class UserDataHandler:
+    NODE_CLONED: int
+    NODE_IMPORTED: int
+    NODE_DELETED: int
+    NODE_RENAMED: int
+
+XML_NAMESPACE: str
+XMLNS_NAMESPACE: str
+XHTML_NAMESPACE: str
+EMPTY_NAMESPACE: None
+EMPTY_PREFIX: None

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

@@ -0,0 +1,8 @@
+from _typeshed.xml import DOMImplementation
+from collections.abc import Callable, Iterable
+
+well_known_implementations: dict[str, str]
+registered: dict[str, Callable[[], DOMImplementation]]
+
+def registerDOMImplementation(name: str, factory: Callable[[], DOMImplementation]) -> None: ...
+def getDOMImplementation(name: str | None = None, features: str | Iterable[tuple[str, str | None]] = ()) -> DOMImplementation: ...

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

@@ -0,0 +1,100 @@
+from _typeshed import Incomplete, ReadableBuffer, SupportsRead
+from typing import Any, NoReturn
+from xml.dom.minidom import Document, DOMImplementation, Node, TypeInfo
+from xml.dom.xmlbuilder import DOMBuilderFilter, Options
+
+TEXT_NODE = Node.TEXT_NODE
+CDATA_SECTION_NODE = Node.CDATA_SECTION_NODE
+DOCUMENT_NODE = Node.DOCUMENT_NODE
+FILTER_ACCEPT = DOMBuilderFilter.FILTER_ACCEPT
+FILTER_REJECT = DOMBuilderFilter.FILTER_REJECT
+FILTER_SKIP = DOMBuilderFilter.FILTER_SKIP
+FILTER_INTERRUPT = DOMBuilderFilter.FILTER_INTERRUPT
+theDOMImplementation: DOMImplementation | None
+
+class ElementInfo:
+    tagName: Incomplete
+    def __init__(self, tagName, model: Incomplete | None = None) -> None: ...
+    def getAttributeType(self, aname) -> TypeInfo: ...
+    def getAttributeTypeNS(self, namespaceURI, localName) -> TypeInfo: ...
+    def isElementContent(self) -> bool: ...
+    def isEmpty(self) -> bool: ...
+    def isId(self, aname) -> bool: ...
+    def isIdNS(self, euri, ename, auri, aname) -> bool: ...
+
+class ExpatBuilder:
+    document: Document  # Created in self.reset()
+    curNode: Incomplete  # Created in self.reset()
+    def __init__(self, options: Options | None = None) -> None: ...
+    def createParser(self): ...
+    def getParser(self): ...
+    def reset(self) -> None: ...
+    def install(self, parser) -> None: ...
+    def parseFile(self, file: SupportsRead[ReadableBuffer | str]) -> Document: ...
+    def parseString(self, string: str | ReadableBuffer) -> Document: ...
+    def start_doctype_decl_handler(self, doctypeName, systemId, publicId, has_internal_subset) -> None: ...
+    def end_doctype_decl_handler(self) -> None: ...
+    def pi_handler(self, target, data) -> None: ...
+    def character_data_handler_cdata(self, data) -> None: ...
+    def character_data_handler(self, data) -> None: ...
+    def start_cdata_section_handler(self) -> None: ...
+    def end_cdata_section_handler(self) -> None: ...
+    def entity_decl_handler(self, entityName, is_parameter_entity, value, base, systemId, publicId, notationName) -> None: ...
+    def notation_decl_handler(self, notationName, base, systemId, publicId) -> None: ...
+    def comment_handler(self, data) -> None: ...
+    def external_entity_ref_handler(self, context, base, systemId, publicId) -> int: ...
+    def first_element_handler(self, name, attributes) -> None: ...
+    def start_element_handler(self, name, attributes) -> None: ...
+    def end_element_handler(self, name) -> None: ...
+    def element_decl_handler(self, name, model) -> None: ...
+    def attlist_decl_handler(self, elem, name, type, default, required) -> None: ...
+    def xml_decl_handler(self, version, encoding, standalone) -> None: ...
+
+class FilterVisibilityController:
+    filter: DOMBuilderFilter
+    def __init__(self, filter: DOMBuilderFilter) -> None: ...
+    def startContainer(self, node: Node) -> int: ...
+    def acceptNode(self, node: Node) -> int: ...
+
+class FilterCrutch:
+    def __init__(self, builder) -> None: ...
+
+class Rejecter(FilterCrutch):
+    def start_element_handler(self, *args: Any) -> None: ...
+    def end_element_handler(self, *args: Any) -> None: ...
+
+class Skipper(FilterCrutch):
+    def start_element_handler(self, *args: Any) -> None: ...
+    def end_element_handler(self, *args: Any) -> None: ...
+
+class FragmentBuilder(ExpatBuilder):
+    fragment: Incomplete | None
+    originalDocument: Incomplete
+    context: Incomplete
+    def __init__(self, context, options: Options | None = None) -> None: ...
+
+class Namespaces:
+    def createParser(self): ...
+    def install(self, parser) -> None: ...
+    def start_namespace_decl_handler(self, prefix, uri) -> None: ...
+    def start_element_handler(self, name, attributes) -> None: ...
+    def end_element_handler(self, name) -> None: ...
+
+class ExpatBuilderNS(Namespaces, ExpatBuilder): ...
+class FragmentBuilderNS(Namespaces, FragmentBuilder): ...
+class ParseEscape(Exception): ...
+
+class InternalSubsetExtractor(ExpatBuilder):
+    subset: Any | None
+    def getSubset(self) -> Any | None: ...
+    def parseFile(self, file: SupportsRead[ReadableBuffer | str]) -> None: ...  # type: ignore[override]
+    def parseString(self, string: str | ReadableBuffer) -> None: ...  # type: ignore[override]
+    def start_doctype_decl_handler(self, name, publicId, systemId, has_internal_subset) -> None: ...  # type: ignore[override]
+    def end_doctype_decl_handler(self) -> NoReturn: ...
+    def start_element_handler(self, name, attrs) -> NoReturn: ...
+
+def parse(file: str | SupportsRead[ReadableBuffer | str], namespaces: bool = True): ...
+def parseString(string: str | ReadableBuffer, namespaces: bool = True): ...
+def parseFragment(file, context, namespaces: bool = True): ...
+def parseFragmentString(string: str, context, namespaces: bool = True): ...
+def makeBuilder(options: Options) -> ExpatBuilderNS | ExpatBuilder: ...