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

mypy/typeshed/stdlib/profile.pyi

@@ -0,0 +1,31 @@
+from _typeshed import StrOrBytesPath
+from collections.abc import Callable
+from typing import Any, TypeVar
+from typing_extensions import ParamSpec, Self, TypeAlias
+
+__all__ = ["run", "runctx", "Profile"]
+
+def run(statement: str, filename: str | None = None, sort: str | int = -1) -> None: ...
+def runctx(
+    statement: str, globals: dict[str, Any], locals: dict[str, Any], filename: str | None = None, sort: str | int = -1
+) -> None: ...
+
+_T = TypeVar("_T")
+_P = ParamSpec("_P")
+_Label: TypeAlias = tuple[str, int, str]
+
+class Profile:
+    bias: int
+    stats: dict[_Label, tuple[int, int, int, int, dict[_Label, tuple[int, int, int, int]]]]  # undocumented
+    def __init__(self, timer: Callable[[], float] | None = None, bias: int | None = None) -> None: ...
+    def set_cmd(self, cmd: str) -> None: ...
+    def simulate_call(self, name: str) -> None: ...
+    def simulate_cmd_complete(self) -> None: ...
+    def print_stats(self, sort: str | int = -1) -> None: ...
+    def dump_stats(self, file: StrOrBytesPath) -> None: ...
+    def create_stats(self) -> None: ...
+    def snapshot_stats(self) -> None: ...
+    def run(self, cmd: str) -> Self: ...
+    def runctx(self, cmd: str, globals: dict[str, Any], locals: dict[str, Any]) -> Self: ...
+    def runcall(self, __func: Callable[_P, _T], *args: _P.args, **kw: _P.kwargs) -> _T: ...
+    def calibrate(self, m: int, verbose: int = 0) -> float: ...

mypy/typeshed/stdlib/pstats.pyi

@@ -0,0 +1,78 @@
+import sys
+from _typeshed import StrEnum, StrOrBytesPath
+from collections.abc import Iterable
+from cProfile import Profile as _cProfile
+from profile import Profile
+from typing import IO, Any, Literal, overload
+from typing_extensions import Self, TypeAlias
+
+if sys.version_info >= (3, 9):
+    __all__ = ["Stats", "SortKey", "FunctionProfile", "StatsProfile"]
+else:
+    __all__ = ["Stats", "SortKey"]
+
+_Selector: TypeAlias = str | float | int
+
+class SortKey(StrEnum):
+    CALLS: str
+    CUMULATIVE: str
+    FILENAME: str
+    LINE: str
+    NAME: str
+    NFL: str
+    PCALLS: str
+    STDNAME: str
+    TIME: str
+
+if sys.version_info >= (3, 9):
+    from dataclasses import dataclass
+
+    @dataclass(unsafe_hash=True)
+    class FunctionProfile:
+        ncalls: str
+        tottime: float
+        percall_tottime: float
+        cumtime: float
+        percall_cumtime: float
+        file_name: str
+        line_number: int
+    @dataclass(unsafe_hash=True)
+    class StatsProfile:
+        total_tt: float
+        func_profiles: dict[str, FunctionProfile]
+
+_SortArgDict: TypeAlias = dict[str, tuple[tuple[tuple[int, int], ...], str]]
+
+class Stats:
+    sort_arg_dict_default: _SortArgDict
+    def __init__(
+        self,
+        __arg: None | str | Profile | _cProfile = ...,
+        *args: None | str | Profile | _cProfile | Self,
+        stream: IO[Any] | None = None,
+    ) -> None: ...
+    def init(self, arg: None | str | Profile | _cProfile) -> None: ...
+    def load_stats(self, arg: None | str | Profile | _cProfile) -> None: ...
+    def get_top_level_stats(self) -> None: ...
+    def add(self, *arg_list: None | str | Profile | _cProfile | Self) -> Self: ...
+    def dump_stats(self, filename: StrOrBytesPath) -> None: ...
+    def get_sort_arg_defs(self) -> _SortArgDict: ...
+    @overload
+    def sort_stats(self, field: Literal[-1, 0, 1, 2]) -> Self: ...
+    @overload
+    def sort_stats(self, *field: str) -> Self: ...
+    def reverse_order(self) -> Self: ...
+    def strip_dirs(self) -> Self: ...
+    def calc_callees(self) -> None: ...
+    def eval_print_amount(self, sel: _Selector, list: list[str], msg: str) -> tuple[list[str], str]: ...
+    if sys.version_info >= (3, 9):
+        def get_stats_profile(self) -> StatsProfile: ...
+
+    def get_print_list(self, sel_list: Iterable[_Selector]) -> tuple[int, list[str]]: ...
+    def print_stats(self, *amount: _Selector) -> Self: ...
+    def print_callees(self, *amount: _Selector) -> Self: ...
+    def print_callers(self, *amount: _Selector) -> Self: ...
+    def print_call_heading(self, name_size: int, column_title: str) -> None: ...
+    def print_call_line(self, name_size: int, source: str, call_dict: dict[str, Any], arrow: str = "->") -> None: ...
+    def print_title(self) -> None: ...
+    def print_line(self, func: str) -> None: ...

mypy/typeshed/stdlib/pty.pyi

@@ -0,0 +1,19 @@
+import sys
+from collections.abc import Callable, Iterable
+from typing import Literal
+from typing_extensions import TypeAlias
+
+if sys.platform != "win32":
+    __all__ = ["openpty", "fork", "spawn"]
+    _Reader: TypeAlias = Callable[[int], bytes]
+
+    STDIN_FILENO: Literal[0]
+    STDOUT_FILENO: Literal[1]
+    STDERR_FILENO: Literal[2]
+
+    CHILD: Literal[0]
+    def openpty() -> tuple[int, int]: ...
+    def master_open() -> tuple[int, str]: ...  # deprecated, use openpty()
+    def slave_open(tty_name: str) -> int: ...  # deprecated, use openpty()
+    def fork() -> tuple[int, int]: ...
+    def spawn(argv: str | Iterable[str], master_read: _Reader = ..., stdin_read: _Reader = ...) -> int: ...

mypy/typeshed/stdlib/pwd.pyi

@@ -0,0 +1,27 @@
+import sys
+from _typeshed import structseq
+from typing import Any, Final, final
+
+if sys.platform != "win32":
+    @final
+    class struct_passwd(structseq[Any], tuple[str, str, int, int, str, str, str]):
+        if sys.version_info >= (3, 10):
+            __match_args__: Final = ("pw_name", "pw_passwd", "pw_uid", "pw_gid", "pw_gecos", "pw_dir", "pw_shell")
+        @property
+        def pw_name(self) -> str: ...
+        @property
+        def pw_passwd(self) -> str: ...
+        @property
+        def pw_uid(self) -> int: ...
+        @property
+        def pw_gid(self) -> int: ...
+        @property
+        def pw_gecos(self) -> str: ...
+        @property
+        def pw_dir(self) -> str: ...
+        @property
+        def pw_shell(self) -> str: ...
+
+    def getpwall() -> list[struct_passwd]: ...
+    def getpwuid(__uid: int) -> struct_passwd: ...
+    def getpwnam(__name: str) -> struct_passwd: ...

mypy/typeshed/stdlib/py_compile.pyi

@@ -0,0 +1,34 @@
+import enum
+import sys
+from typing import AnyStr
+
+__all__ = ["compile", "main", "PyCompileError", "PycInvalidationMode"]
+
+class PyCompileError(Exception):
+    exc_type_name: str
+    exc_value: BaseException
+    file: str
+    msg: str
+    def __init__(self, exc_type: type[BaseException], exc_value: BaseException, file: str, msg: str = "") -> None: ...
+
+class PycInvalidationMode(enum.Enum):
+    TIMESTAMP: int
+    CHECKED_HASH: int
+    UNCHECKED_HASH: int
+
+def _get_default_invalidation_mode() -> PycInvalidationMode: ...
+def compile(
+    file: AnyStr,
+    cfile: AnyStr | None = None,
+    dfile: AnyStr | None = None,
+    doraise: bool = False,
+    optimize: int = -1,
+    invalidation_mode: PycInvalidationMode | None = None,
+    quiet: int = 0,
+) -> AnyStr | None: ...
+
+if sys.version_info >= (3, 10):
+    def main() -> None: ...
+
+else:
+    def main(args: list[str] | None = None) -> int: ...

mypy/typeshed/stdlib/pyclbr.pyi

@@ -0,0 +1,74 @@
+import sys
+from collections.abc import Mapping, Sequence
+
+__all__ = ["readmodule", "readmodule_ex", "Class", "Function"]
+
+class _Object:
+    module: str
+    name: str
+    file: int
+    lineno: int
+
+    if sys.version_info >= (3, 10):
+        end_lineno: int | None
+
+    parent: _Object | None
+
+    # This is a dict at runtime, but we're typing it as Mapping to
+    # avoid variance issues in the subclasses
+    children: Mapping[str, _Object]
+
+    if sys.version_info >= (3, 10):
+        def __init__(
+            self, module: str, name: str, file: str, lineno: int, end_lineno: int | None, parent: _Object | None
+        ) -> None: ...
+    else:
+        def __init__(self, module: str, name: str, file: str, lineno: int, parent: _Object | None) -> None: ...
+
+class Function(_Object):
+    if sys.version_info >= (3, 10):
+        is_async: bool
+
+    parent: Function | Class | None
+    children: dict[str, Class | Function]
+
+    if sys.version_info >= (3, 10):
+        def __init__(
+            self,
+            module: str,
+            name: str,
+            file: str,
+            lineno: int,
+            parent: Function | Class | None = None,
+            is_async: bool = False,
+            *,
+            end_lineno: int | None = None,
+        ) -> None: ...
+    else:
+        def __init__(self, module: str, name: str, file: str, lineno: int, parent: Function | Class | None = None) -> None: ...
+
+class Class(_Object):
+    super: list[Class | str] | None
+    methods: dict[str, int]
+    parent: Class | None
+    children: dict[str, Class | Function]
+
+    if sys.version_info >= (3, 10):
+        def __init__(
+            self,
+            module: str,
+            name: str,
+            super_: list[Class | str] | None,
+            file: str,
+            lineno: int,
+            parent: Class | None = None,
+            *,
+            end_lineno: int | None = None,
+        ) -> None: ...
+    else:
+        def __init__(
+            self, module: str, name: str, super: list[Class | str] | None, file: str, lineno: int, parent: Class | None = None
+        ) -> None: ...
+
+def readmodule(module: str, path: Sequence[str] | None = None) -> dict[str, Class]: ...
+def readmodule_ex(module: str, path: Sequence[str] | None = None) -> dict[str, Class | Function | list[str]]: ...

mypy/typeshed/stdlib/pydoc.pyi

@@ -0,0 +1,261 @@
+import sys
+from _typeshed import OptExcInfo, SupportsWrite
+from abc import abstractmethod
+from builtins import list as _list  # "list" conflicts with method name
+from collections.abc import Callable, Container, Mapping, MutableMapping
+from reprlib import Repr
+from types import MethodType, ModuleType, TracebackType
+from typing import IO, Any, AnyStr, Final, NoReturn, TypeVar
+from typing_extensions import TypeGuard
+
+__all__ = ["help"]
+
+_T = TypeVar("_T")
+
+__author__: Final[str]
+__date__: Final[str]
+__version__: Final[str]
+__credits__: Final[str]
+
+def pathdirs() -> list[str]: ...
+def getdoc(object: object) -> str: ...
+def splitdoc(doc: AnyStr) -> tuple[AnyStr, AnyStr]: ...
+def classname(object: object, modname: str) -> str: ...
+def isdata(object: object) -> bool: ...
+def replace(text: AnyStr, *pairs: AnyStr) -> AnyStr: ...
+def cram(text: str, maxlen: int) -> str: ...
+def stripid(text: str) -> str: ...
+def allmethods(cl: type) -> MutableMapping[str, MethodType]: ...
+def visiblename(name: str, all: Container[str] | None = None, obj: object = None) -> bool: ...
+def classify_class_attrs(object: object) -> list[tuple[str, str, type, str]]: ...
+def ispackage(path: str) -> bool: ...
+def source_synopsis(file: IO[AnyStr]) -> AnyStr | None: ...
+def synopsis(filename: str, cache: MutableMapping[str, tuple[int, str]] = {}) -> str | None: ...
+
+class ErrorDuringImport(Exception):
+    filename: str
+    exc: type[BaseException] | None
+    value: BaseException | None
+    tb: TracebackType | None
+    def __init__(self, filename: str, exc_info: OptExcInfo) -> None: ...
+
+def importfile(path: str) -> ModuleType: ...
+def safeimport(path: str, forceload: bool = ..., cache: MutableMapping[str, ModuleType] = {}) -> ModuleType | None: ...
+
+class Doc:
+    PYTHONDOCS: str
+    def document(self, object: object, name: str | None = None, *args: Any) -> str: ...
+    def fail(self, object: object, name: str | None = None, *args: Any) -> NoReturn: ...
+    @abstractmethod
+    def docmodule(self, object: object, name: str | None = None, *args: Any) -> str: ...
+    @abstractmethod
+    def docclass(self, object: object, name: str | None = None, *args: Any) -> str: ...
+    @abstractmethod
+    def docroutine(self, object: object, name: str | None = None, *args: Any) -> str: ...
+    @abstractmethod
+    def docother(self, object: object, name: str | None = None, *args: Any) -> str: ...
+    @abstractmethod
+    def docproperty(self, object: object, name: str | None = None, *args: Any) -> str: ...
+    @abstractmethod
+    def docdata(self, object: object, name: str | None = None, *args: Any) -> str: ...
+    def getdocloc(self, object: object, basedir: str = ...) -> str | None: ...
+
+class HTMLRepr(Repr):
+    def __init__(self) -> None: ...
+    def escape(self, text: str) -> str: ...
+    def repr(self, object: object) -> str: ...
+    def repr1(self, x: object, level: complex) -> str: ...
+    def repr_string(self, x: str, level: complex) -> str: ...
+    def repr_str(self, x: str, level: complex) -> str: ...
+    def repr_instance(self, x: object, level: complex) -> str: ...
+    def repr_unicode(self, x: AnyStr, level: complex) -> str: ...
+
+class HTMLDoc(Doc):
+    _repr_instance: HTMLRepr
+    repr = _repr_instance.repr
+    escape = _repr_instance.escape
+    def page(self, title: str, contents: str) -> str: ...
+    if sys.version_info >= (3, 11):
+        def heading(self, title: str, extras: str = "") -> str: ...
+        def section(
+            self,
+            title: str,
+            cls: str,
+            contents: str,
+            width: int = 6,
+            prelude: str = "",
+            marginalia: str | None = None,
+            gap: str = " ",
+        ) -> str: ...
+        def multicolumn(self, list: list[_T], format: Callable[[_T], str]) -> str: ...
+    else:
+        def heading(self, title: str, fgcol: str, bgcol: str, extras: str = "") -> str: ...
+        def section(
+            self,
+            title: str,
+            fgcol: str,
+            bgcol: str,
+            contents: str,
+            width: int = 6,
+            prelude: str = "",
+            marginalia: str | None = None,
+            gap: str = " ",
+        ) -> str: ...
+        def multicolumn(self, list: list[_T], format: Callable[[_T], str], cols: int = 4) -> str: ...
+
+    def bigsection(self, title: str, *args: Any) -> str: ...
+    def preformat(self, text: str) -> str: ...
+    def grey(self, text: str) -> str: ...
+    def namelink(self, name: str, *dicts: MutableMapping[str, str]) -> str: ...
+    def classlink(self, object: object, modname: str) -> str: ...
+    def modulelink(self, object: object) -> str: ...
+    def modpkglink(self, modpkginfo: tuple[str, str, bool, bool]) -> str: ...
+    def markup(
+        self,
+        text: str,
+        escape: Callable[[str], str] | None = None,
+        funcs: Mapping[str, str] = {},
+        classes: Mapping[str, str] = {},
+        methods: Mapping[str, str] = {},
+    ) -> str: ...
+    def formattree(
+        self, tree: list[tuple[type, tuple[type, ...]] | list[Any]], modname: str, parent: type | None = None
+    ) -> str: ...
+    def docmodule(self, object: object, name: str | None = None, mod: str | None = None, *ignored: Any) -> str: ...
+    def docclass(
+        self,
+        object: object,
+        name: str | None = None,
+        mod: str | None = None,
+        funcs: Mapping[str, str] = {},
+        classes: Mapping[str, str] = {},
+        *ignored: Any,
+    ) -> str: ...
+    def formatvalue(self, object: object) -> str: ...
+    def docroutine(  # type: ignore[override]
+        self,
+        object: object,
+        name: str | None = None,
+        mod: str | None = None,
+        funcs: Mapping[str, str] = {},
+        classes: Mapping[str, str] = {},
+        methods: Mapping[str, str] = {},
+        cl: type | None = None,
+    ) -> str: ...
+    def docproperty(self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
+    def docother(self, object: object, name: str | None = None, mod: Any | None = None, *ignored: Any) -> str: ...
+    def docdata(self, object: object, name: str | None = None, mod: Any | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
+    def index(self, dir: str, shadowed: MutableMapping[str, bool] | None = None) -> str: ...
+    def filelink(self, url: str, path: str) -> str: ...
+
+class TextRepr(Repr):
+    def __init__(self) -> None: ...
+    def repr1(self, x: object, level: complex) -> str: ...
+    def repr_string(self, x: str, level: complex) -> str: ...
+    def repr_str(self, x: str, level: complex) -> str: ...
+    def repr_instance(self, x: object, level: complex) -> str: ...
+
+class TextDoc(Doc):
+    _repr_instance: TextRepr
+    repr = _repr_instance.repr
+    def bold(self, text: str) -> str: ...
+    def indent(self, text: str, prefix: str = "    ") -> str: ...
+    def section(self, title: str, contents: str) -> str: ...
+    def formattree(
+        self, tree: list[tuple[type, tuple[type, ...]] | list[Any]], modname: str, parent: type | None = None, prefix: str = ""
+    ) -> str: ...
+    def docmodule(self, object: object, name: str | None = None, mod: Any | None = None) -> str: ...  # type: ignore[override]
+    def docclass(self, object: object, name: str | None = None, mod: str | None = None, *ignored: Any) -> str: ...
+    def formatvalue(self, object: object) -> str: ...
+    def docroutine(self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
+    def docproperty(self, object: object, name: str | None = None, mod: Any | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
+    def docdata(self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
+    def docother(  # type: ignore[override]
+        self,
+        object: object,
+        name: str | None = None,
+        mod: str | None = None,
+        parent: str | None = None,
+        maxlen: int | None = None,
+        doc: Any | None = None,
+    ) -> str: ...
+
+def pager(text: str) -> None: ...
+def getpager() -> Callable[[str], None]: ...
+def plain(text: str) -> str: ...
+def pipepager(text: str, cmd: str) -> None: ...
+def tempfilepager(text: str, cmd: str) -> None: ...
+def ttypager(text: str) -> None: ...
+def plainpager(text: str) -> None: ...
+def describe(thing: Any) -> str: ...
+def locate(path: str, forceload: bool = ...) -> object: ...
+
+text: TextDoc
+html: HTMLDoc
+
+def resolve(thing: str | object, forceload: bool = ...) -> tuple[object, str] | None: ...
+def render_doc(
+    thing: str | object, title: str = "Python Library Documentation: %s", forceload: bool = ..., renderer: Doc | None = None
+) -> str: ...
+
+if sys.version_info >= (3, 11):
+    def doc(
+        thing: str | object,
+        title: str = "Python Library Documentation: %s",
+        forceload: bool = ...,
+        output: SupportsWrite[str] | None = None,
+        is_cli: bool = False,
+    ) -> None: ...
+
+else:
+    def doc(
+        thing: str | object,
+        title: str = "Python Library Documentation: %s",
+        forceload: bool = ...,
+        output: SupportsWrite[str] | None = None,
+    ) -> None: ...
+
+def writedoc(thing: str | object, forceload: bool = ...) -> None: ...
+def writedocs(dir: str, pkgpath: str = "", done: Any | None = None) -> None: ...
+
+class Helper:
+    keywords: dict[str, str | tuple[str, str]]
+    symbols: dict[str, str]
+    topics: dict[str, str | tuple[str, ...]]
+    def __init__(self, input: IO[str] | None = None, output: IO[str] | None = None) -> None: ...
+    @property
+    def input(self) -> IO[str]: ...
+    @property
+    def output(self) -> IO[str]: ...
+    def __call__(self, request: str | Helper | object = ...) -> None: ...
+    def interact(self) -> None: ...
+    def getline(self, prompt: str) -> str: ...
+    if sys.version_info >= (3, 11):
+        def help(self, request: Any, is_cli: bool = False) -> None: ...
+    else:
+        def help(self, request: Any) -> None: ...
+
+    def intro(self) -> None: ...
+    def list(self, items: _list[str], columns: int = 4, width: int = 80) -> None: ...
+    def listkeywords(self) -> None: ...
+    def listsymbols(self) -> None: ...
+    def listtopics(self) -> None: ...
+    def showtopic(self, topic: str, more_xrefs: str = "") -> None: ...
+    def showsymbol(self, symbol: str) -> None: ...
+    def listmodules(self, key: str = "") -> None: ...
+
+help: Helper
+
+class ModuleScanner:
+    quit: bool
+    def run(
+        self,
+        callback: Callable[[str | None, str, str], object],
+        key: str | None = None,
+        completer: Callable[[], object] | None = None,
+        onerror: Callable[[str], object] | None = None,
+    ) -> None: ...
+
+def apropos(key: str) -> None: ...
+def ispath(x: object) -> TypeGuard[str]: ...
+def cli() -> None: ...

mypy/typeshed/stdlib/pydoc_data/topics.pyi

@@ -0,0 +1 @@
+topics: dict[str, str]

mypy/typeshed/stdlib/pyexpat/__init__.pyi

@@ -0,0 +1,80 @@
+from _typeshed import ReadableBuffer, SupportsRead
+from collections.abc import Callable
+from pyexpat import errors as errors, model as model
+from typing import Any, final
+from typing_extensions import TypeAlias
+
+EXPAT_VERSION: str  # undocumented
+version_info: tuple[int, int, int]  # undocumented
+native_encoding: str  # undocumented
+features: list[tuple[str, int]]  # undocumented
+
+class ExpatError(Exception):
+    code: int
+    lineno: int
+    offset: int
+
+error = ExpatError
+
+XML_PARAM_ENTITY_PARSING_NEVER: int
+XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE: int
+XML_PARAM_ENTITY_PARSING_ALWAYS: int
+
+_Model: TypeAlias = tuple[int, int, str | None, tuple[Any, ...]]
+
+@final
+class XMLParserType:
+    def Parse(self, __data: str | ReadableBuffer, __isfinal: bool = False) -> int: ...
+    def ParseFile(self, __file: SupportsRead[bytes]) -> int: ...
+    def SetBase(self, __base: str) -> None: ...
+    def GetBase(self) -> str | None: ...
+    def GetInputContext(self) -> bytes | None: ...
+    def ExternalEntityParserCreate(self, __context: str | None, __encoding: str = ...) -> XMLParserType: ...
+    def SetParamEntityParsing(self, __flag: int) -> int: ...
+    def UseForeignDTD(self, __flag: bool = True) -> None: ...
+    @property
+    def intern(self) -> dict[str, str]: ...
+    buffer_size: int
+    buffer_text: bool
+    buffer_used: int
+    namespace_prefixes: bool  # undocumented
+    ordered_attributes: bool
+    specified_attributes: bool
+    ErrorByteIndex: int
+    ErrorCode: int
+    ErrorColumnNumber: int
+    ErrorLineNumber: int
+    CurrentByteIndex: int
+    CurrentColumnNumber: int
+    CurrentLineNumber: int
+    XmlDeclHandler: Callable[[str, str | None, int], Any] | None
+    StartDoctypeDeclHandler: Callable[[str, str | None, str | None, bool], Any] | None
+    EndDoctypeDeclHandler: Callable[[], Any] | None
+    ElementDeclHandler: Callable[[str, _Model], Any] | None
+    AttlistDeclHandler: Callable[[str, str, str, str | None, bool], Any] | None
+    StartElementHandler: Callable[[str, dict[str, str]], Any] | Callable[[str, list[str]], Any] | Callable[
+        [str, dict[str, str], list[str]], Any
+    ] | None
+    EndElementHandler: Callable[[str], Any] | None
+    ProcessingInstructionHandler: Callable[[str, str], Any] | None
+    CharacterDataHandler: Callable[[str], Any] | None
+    UnparsedEntityDeclHandler: Callable[[str, str | None, str, str | None, str], Any] | None
+    EntityDeclHandler: Callable[[str, bool, str | None, str | None, str, str | None, str | None], Any] | None
+    NotationDeclHandler: Callable[[str, str | None, str, str | None], Any] | None
+    StartNamespaceDeclHandler: Callable[[str, str], Any] | None
+    EndNamespaceDeclHandler: Callable[[str], Any] | None
+    CommentHandler: Callable[[str], Any] | None
+    StartCdataSectionHandler: Callable[[], Any] | None
+    EndCdataSectionHandler: Callable[[], Any] | None
+    DefaultHandler: Callable[[str], Any] | None
+    DefaultHandlerExpand: Callable[[str], Any] | None
+    NotStandaloneHandler: Callable[[], int] | None
+    ExternalEntityRefHandler: Callable[[str, str | None, str | None, str | None], int] | None
+    SkippedEntityHandler: Callable[[str, bool], Any] | None
+
+def ErrorString(__code: int) -> str: ...
+
+# intern is undocumented
+def ParserCreate(
+    encoding: str | None = None, namespace_separator: str | None = None, intern: dict[str, Any] | None = None
+) -> XMLParserType: ...

mypy/typeshed/stdlib/pyexpat/errors.pyi

@@ -0,0 +1,49 @@
+import sys
+
+codes: dict[str, int]
+messages: dict[int, str]
+
+XML_ERROR_ABORTED: str
+XML_ERROR_ASYNC_ENTITY: str
+XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF: str
+XML_ERROR_BAD_CHAR_REF: str
+XML_ERROR_BINARY_ENTITY_REF: str
+XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING: str
+XML_ERROR_DUPLICATE_ATTRIBUTE: str
+XML_ERROR_ENTITY_DECLARED_IN_PE: str
+XML_ERROR_EXTERNAL_ENTITY_HANDLING: str
+XML_ERROR_FEATURE_REQUIRES_XML_DTD: str
+XML_ERROR_FINISHED: str
+XML_ERROR_INCOMPLETE_PE: str
+XML_ERROR_INCORRECT_ENCODING: str
+XML_ERROR_INVALID_TOKEN: str
+XML_ERROR_JUNK_AFTER_DOC_ELEMENT: str
+XML_ERROR_MISPLACED_XML_PI: str
+XML_ERROR_NOT_STANDALONE: str
+XML_ERROR_NOT_SUSPENDED: str
+XML_ERROR_NO_ELEMENTS: str
+XML_ERROR_NO_MEMORY: str
+XML_ERROR_PARAM_ENTITY_REF: str
+XML_ERROR_PARTIAL_CHAR: str
+XML_ERROR_PUBLICID: str
+XML_ERROR_RECURSIVE_ENTITY_REF: str
+XML_ERROR_SUSPENDED: str
+XML_ERROR_SUSPEND_PE: str
+XML_ERROR_SYNTAX: str
+XML_ERROR_TAG_MISMATCH: str
+XML_ERROR_TEXT_DECL: str
+XML_ERROR_UNBOUND_PREFIX: str
+XML_ERROR_UNCLOSED_CDATA_SECTION: str
+XML_ERROR_UNCLOSED_TOKEN: str
+XML_ERROR_UNDECLARING_PREFIX: str
+XML_ERROR_UNDEFINED_ENTITY: str
+XML_ERROR_UNEXPECTED_STATE: str
+XML_ERROR_UNKNOWN_ENCODING: str
+XML_ERROR_XML_DECL: str
+if sys.version_info >= (3, 11):
+    XML_ERROR_RESERVED_PREFIX_XML: str
+    XML_ERROR_RESERVED_PREFIX_XMLNS: str
+    XML_ERROR_RESERVED_NAMESPACE_URI: str
+    XML_ERROR_INVALID_ARGUMENT: str
+    XML_ERROR_NO_BUFFER: str
+    XML_ERROR_AMPLIFICATION_LIMIT_BREACH: str

mypy/typeshed/stdlib/pyexpat/model.pyi

@@ -0,0 +1,11 @@
+XML_CTYPE_ANY: int
+XML_CTYPE_CHOICE: int
+XML_CTYPE_EMPTY: int
+XML_CTYPE_MIXED: int
+XML_CTYPE_NAME: int
+XML_CTYPE_SEQ: int
+
+XML_CQUANT_NONE: int
+XML_CQUANT_OPT: int
+XML_CQUANT_PLUS: int
+XML_CQUANT_REP: int