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

mypy/typeshed/stdlib/nt.pyi

@@ -0,0 +1,111 @@
+import sys
+
+if sys.platform == "win32":
+    # Actually defined here and re-exported from os at runtime,
+    # but this leads to less code duplication
+    from os import (
+        F_OK as F_OK,
+        O_APPEND as O_APPEND,
+        O_BINARY as O_BINARY,
+        O_CREAT as O_CREAT,
+        O_EXCL as O_EXCL,
+        O_NOINHERIT as O_NOINHERIT,
+        O_RANDOM as O_RANDOM,
+        O_RDONLY as O_RDONLY,
+        O_RDWR as O_RDWR,
+        O_SEQUENTIAL as O_SEQUENTIAL,
+        O_SHORT_LIVED as O_SHORT_LIVED,
+        O_TEMPORARY as O_TEMPORARY,
+        O_TEXT as O_TEXT,
+        O_TRUNC as O_TRUNC,
+        O_WRONLY as O_WRONLY,
+        P_DETACH as P_DETACH,
+        P_NOWAIT as P_NOWAIT,
+        P_NOWAITO as P_NOWAITO,
+        P_OVERLAY as P_OVERLAY,
+        P_WAIT as P_WAIT,
+        R_OK as R_OK,
+        TMP_MAX as TMP_MAX,
+        W_OK as W_OK,
+        X_OK as X_OK,
+        DirEntry as DirEntry,
+        abort as abort,
+        access as access,
+        chdir as chdir,
+        chmod as chmod,
+        close as close,
+        closerange as closerange,
+        cpu_count as cpu_count,
+        device_encoding as device_encoding,
+        dup as dup,
+        dup2 as dup2,
+        error as error,
+        execv as execv,
+        execve as execve,
+        fspath as fspath,
+        fstat as fstat,
+        fsync as fsync,
+        ftruncate as ftruncate,
+        get_handle_inheritable as get_handle_inheritable,
+        get_inheritable as get_inheritable,
+        get_terminal_size as get_terminal_size,
+        getcwd as getcwd,
+        getcwdb as getcwdb,
+        getlogin as getlogin,
+        getpid as getpid,
+        getppid as getppid,
+        isatty as isatty,
+        kill as kill,
+        link as link,
+        listdir as listdir,
+        lseek as lseek,
+        lstat as lstat,
+        mkdir as mkdir,
+        open as open,
+        pipe as pipe,
+        putenv as putenv,
+        read as read,
+        readlink as readlink,
+        remove as remove,
+        rename as rename,
+        replace as replace,
+        rmdir as rmdir,
+        scandir as scandir,
+        set_handle_inheritable as set_handle_inheritable,
+        set_inheritable as set_inheritable,
+        spawnv as spawnv,
+        spawnve as spawnve,
+        startfile as startfile,
+        stat as stat,
+        stat_result as stat_result,
+        statvfs_result as statvfs_result,
+        strerror as strerror,
+        symlink as symlink,
+        system as system,
+        terminal_size as terminal_size,
+        times as times,
+        times_result as times_result,
+        truncate as truncate,
+        umask as umask,
+        uname_result as uname_result,
+        unlink as unlink,
+        urandom as urandom,
+        utime as utime,
+        waitpid as waitpid,
+        write as write,
+    )
+
+    if sys.version_info >= (3, 9):
+        from os import unsetenv as unsetenv, waitstatus_to_exitcode as waitstatus_to_exitcode
+    if sys.version_info >= (3, 11):
+        from os import EX_OK as EX_OK
+    if sys.version_info >= (3, 12):
+        from os import (
+            get_blocking as get_blocking,
+            listdrives as listdrives,
+            listmounts as listmounts,
+            listvolumes as listvolumes,
+            set_blocking as set_blocking,
+        )
+
+    environ: dict[str, str]

mypy/typeshed/stdlib/ntpath.pyi

@@ -0,0 +1,119 @@
+import sys
+from _typeshed import BytesPath, StrPath
+from genericpath import (
+    commonprefix as commonprefix,
+    exists as exists,
+    getatime as getatime,
+    getctime as getctime,
+    getmtime as getmtime,
+    getsize as getsize,
+    isdir as isdir,
+    isfile as isfile,
+    samefile as samefile,
+    sameopenfile as sameopenfile,
+    samestat as samestat,
+)
+from os import PathLike
+
+# Re-export common definitions from posixpath to reduce duplication
+from posixpath import (
+    abspath as abspath,
+    basename as basename,
+    commonpath as commonpath,
+    curdir as curdir,
+    defpath as defpath,
+    devnull as devnull,
+    dirname as dirname,
+    expanduser as expanduser,
+    expandvars as expandvars,
+    extsep as extsep,
+    isabs as isabs,
+    islink as islink,
+    ismount as ismount,
+    lexists as lexists,
+    normcase as normcase,
+    normpath as normpath,
+    pardir as pardir,
+    pathsep as pathsep,
+    relpath as relpath,
+    sep as sep,
+    split as split,
+    splitdrive as splitdrive,
+    splitext as splitext,
+    supports_unicode_filenames as supports_unicode_filenames,
+)
+from typing import AnyStr, overload
+from typing_extensions import LiteralString
+
+if sys.version_info >= (3, 12):
+    from posixpath import isjunction as isjunction, splitroot as splitroot
+
+__all__ = [
+    "normcase",
+    "isabs",
+    "join",
+    "splitdrive",
+    "split",
+    "splitext",
+    "basename",
+    "dirname",
+    "commonprefix",
+    "getsize",
+    "getmtime",
+    "getatime",
+    "getctime",
+    "islink",
+    "exists",
+    "lexists",
+    "isdir",
+    "isfile",
+    "ismount",
+    "expanduser",
+    "expandvars",
+    "normpath",
+    "abspath",
+    "curdir",
+    "pardir",
+    "sep",
+    "pathsep",
+    "defpath",
+    "altsep",
+    "extsep",
+    "devnull",
+    "realpath",
+    "supports_unicode_filenames",
+    "relpath",
+    "samefile",
+    "sameopenfile",
+    "samestat",
+    "commonpath",
+]
+if sys.version_info >= (3, 12):
+    __all__ += ["isjunction", "splitroot"]
+
+altsep: LiteralString
+
+# First parameter is not actually pos-only,
+# but must be defined as pos-only in the stub or cross-platform code doesn't type-check,
+# as the parameter name is different in posixpath.join()
+@overload
+def join(__path: LiteralString, *paths: LiteralString) -> LiteralString: ...
+@overload
+def join(__path: StrPath, *paths: StrPath) -> str: ...
+@overload
+def join(__path: BytesPath, *paths: BytesPath) -> bytes: ...
+
+if sys.platform == "win32":
+    if sys.version_info >= (3, 10):
+        @overload
+        def realpath(path: PathLike[AnyStr], *, strict: bool = False) -> AnyStr: ...
+        @overload
+        def realpath(path: AnyStr, *, strict: bool = False) -> AnyStr: ...
+    else:
+        @overload
+        def realpath(path: PathLike[AnyStr]) -> AnyStr: ...
+        @overload
+        def realpath(path: AnyStr) -> AnyStr: ...
+
+else:
+    realpath = abspath

mypy/typeshed/stdlib/nturl2path.pyi

@@ -0,0 +1,2 @@
+def url2pathname(url: str) -> str: ...
+def pathname2url(p: str) -> str: ...

mypy/typeshed/stdlib/numbers.pyi

@@ -0,0 +1,154 @@
+# Note: these stubs are incomplete. The more complex type
+# signatures are currently omitted.
+#
+# Use SupportsComplex, SupportsFloat and SupportsIndex for return types in this module
+# rather than `numbers.Complex`, `numbers.Real` and `numbers.Integral`,
+# to avoid an excessive number of `type: ignore`s in subclasses of these ABCs
+# (since type checkers don't see `complex` as a subtype of `numbers.Complex`,
+# nor `float` as a subtype of `numbers.Real`, etc.)
+
+import sys
+from _typeshed import Incomplete
+from abc import ABCMeta, abstractmethod
+from typing import Literal, SupportsFloat, SupportsIndex, overload
+from typing_extensions import TypeAlias
+
+if sys.version_info >= (3, 11):
+    from typing import SupportsComplex as _SupportsComplex
+else:
+    # builtins.complex didn't have a __complex__ method on older Pythons
+    import typing
+
+    _SupportsComplex: TypeAlias = typing.SupportsComplex | complex
+
+__all__ = ["Number", "Complex", "Real", "Rational", "Integral"]
+
+class Number(metaclass=ABCMeta):
+    @abstractmethod
+    def __hash__(self) -> int: ...
+
+# See comment at the top of the file
+# for why some of these return types are purposefully vague
+class Complex(Number):
+    @abstractmethod
+    def __complex__(self) -> complex: ...
+    def __bool__(self) -> bool: ...
+    @property
+    @abstractmethod
+    def real(self) -> SupportsFloat: ...
+    @property
+    @abstractmethod
+    def imag(self) -> SupportsFloat: ...
+    @abstractmethod
+    def __add__(self, other) -> _SupportsComplex: ...
+    @abstractmethod
+    def __radd__(self, other) -> _SupportsComplex: ...
+    @abstractmethod
+    def __neg__(self) -> _SupportsComplex: ...
+    @abstractmethod
+    def __pos__(self) -> _SupportsComplex: ...
+    def __sub__(self, other) -> _SupportsComplex: ...
+    def __rsub__(self, other) -> _SupportsComplex: ...
+    @abstractmethod
+    def __mul__(self, other) -> _SupportsComplex: ...
+    @abstractmethod
+    def __rmul__(self, other) -> _SupportsComplex: ...
+    @abstractmethod
+    def __truediv__(self, other) -> _SupportsComplex: ...
+    @abstractmethod
+    def __rtruediv__(self, other) -> _SupportsComplex: ...
+    @abstractmethod
+    def __pow__(self, exponent) -> _SupportsComplex: ...
+    @abstractmethod
+    def __rpow__(self, base) -> _SupportsComplex: ...
+    @abstractmethod
+    def __abs__(self) -> SupportsFloat: ...
+    @abstractmethod
+    def conjugate(self) -> _SupportsComplex: ...
+    @abstractmethod
+    def __eq__(self, other: object) -> bool: ...
+
+# See comment at the top of the file
+# for why some of these return types are purposefully vague
+class Real(Complex, SupportsFloat):
+    @abstractmethod
+    def __float__(self) -> float: ...
+    @abstractmethod
+    def __trunc__(self) -> SupportsIndex: ...
+    @abstractmethod
+    def __floor__(self) -> SupportsIndex: ...
+    @abstractmethod
+    def __ceil__(self) -> SupportsIndex: ...
+    @abstractmethod
+    @overload
+    def __round__(self, ndigits: None = None) -> SupportsIndex: ...
+    @abstractmethod
+    @overload
+    def __round__(self, ndigits: int) -> SupportsFloat: ...
+    def __divmod__(self, other) -> tuple[SupportsFloat, SupportsFloat]: ...
+    def __rdivmod__(self, other) -> tuple[SupportsFloat, SupportsFloat]: ...
+    @abstractmethod
+    def __floordiv__(self, other) -> SupportsFloat: ...
+    @abstractmethod
+    def __rfloordiv__(self, other) -> SupportsFloat: ...
+    @abstractmethod
+    def __mod__(self, other) -> SupportsFloat: ...
+    @abstractmethod
+    def __rmod__(self, other) -> SupportsFloat: ...
+    @abstractmethod
+    def __lt__(self, other) -> bool: ...
+    @abstractmethod
+    def __le__(self, other) -> bool: ...
+    def __complex__(self) -> complex: ...
+    @property
+    def real(self) -> SupportsFloat: ...
+    @property
+    def imag(self) -> Literal[0]: ...
+    def conjugate(self) -> SupportsFloat: ...  # type: ignore[override]
+
+# See comment at the top of the file
+# for why some of these return types are purposefully vague
+class Rational(Real):
+    @property
+    @abstractmethod
+    def numerator(self) -> SupportsIndex: ...
+    @property
+    @abstractmethod
+    def denominator(self) -> SupportsIndex: ...
+    def __float__(self) -> float: ...
+
+# See comment at the top of the file
+# for why some of these return types are purposefully vague
+class Integral(Rational):
+    @abstractmethod
+    def __int__(self) -> int: ...
+    def __index__(self) -> int: ...
+    @abstractmethod
+    def __pow__(self, exponent, modulus: Incomplete | None = None) -> SupportsIndex: ...  # type: ignore[override]
+    @abstractmethod
+    def __lshift__(self, other) -> SupportsIndex: ...
+    @abstractmethod
+    def __rlshift__(self, other) -> SupportsIndex: ...
+    @abstractmethod
+    def __rshift__(self, other) -> SupportsIndex: ...
+    @abstractmethod
+    def __rrshift__(self, other) -> SupportsIndex: ...
+    @abstractmethod
+    def __and__(self, other) -> SupportsIndex: ...
+    @abstractmethod
+    def __rand__(self, other) -> SupportsIndex: ...
+    @abstractmethod
+    def __xor__(self, other) -> SupportsIndex: ...
+    @abstractmethod
+    def __rxor__(self, other) -> SupportsIndex: ...
+    @abstractmethod
+    def __or__(self, other) -> SupportsIndex: ...
+    @abstractmethod
+    def __ror__(self, other) -> SupportsIndex: ...
+    @abstractmethod
+    def __invert__(self) -> SupportsIndex: ...
+    def __float__(self) -> float: ...
+    @property
+    def numerator(self) -> SupportsIndex: ...
+    @property
+    def denominator(self) -> Literal[1]: ...

mypy/typeshed/stdlib/opcode.pyi

@@ -0,0 +1,59 @@
+import sys
+from typing import Literal
+
+__all__ = [
+    "cmp_op",
+    "hasconst",
+    "hasname",
+    "hasjrel",
+    "hasjabs",
+    "haslocal",
+    "hascompare",
+    "hasfree",
+    "opname",
+    "opmap",
+    "HAVE_ARGUMENT",
+    "EXTENDED_ARG",
+    "stack_effect",
+]
+if sys.version_info >= (3, 12):
+    __all__ += ["hasarg", "hasexc"]
+else:
+    __all__ += ["hasnargs"]
+
+if sys.version_info >= (3, 9):
+    cmp_op: tuple[Literal["<"], Literal["<="], Literal["=="], Literal["!="], Literal[">"], Literal[">="]]
+else:
+    cmp_op: tuple[
+        Literal["<"],
+        Literal["<="],
+        Literal["=="],
+        Literal["!="],
+        Literal[">"],
+        Literal[">="],
+        Literal["in"],
+        Literal["not in"],
+        Literal["is"],
+        Literal["is not"],
+        Literal["exception match"],
+        Literal["BAD"],
+    ]
+hasconst: list[int]
+hasname: list[int]
+hasjrel: list[int]
+hasjabs: list[int]
+haslocal: list[int]
+hascompare: list[int]
+hasfree: list[int]
+if sys.version_info >= (3, 12):
+    hasarg: list[int]
+    hasexc: list[int]
+else:
+    hasnargs: list[int]
+opname: list[str]
+
+opmap: dict[str, int]
+HAVE_ARGUMENT: Literal[90]
+EXTENDED_ARG: Literal[144]
+
+def stack_effect(__opcode: int, __oparg: int | None = None, *, jump: bool | None = None) -> int: ...

mypy/typeshed/stdlib/operator.pyi

@@ -0,0 +1,110 @@
+import sys
+from _operator import *
+
+__all__ = [
+    "abs",
+    "add",
+    "and_",
+    "attrgetter",
+    "concat",
+    "contains",
+    "countOf",
+    "delitem",
+    "eq",
+    "floordiv",
+    "ge",
+    "getitem",
+    "gt",
+    "iadd",
+    "iand",
+    "iconcat",
+    "ifloordiv",
+    "ilshift",
+    "imatmul",
+    "imod",
+    "imul",
+    "index",
+    "indexOf",
+    "inv",
+    "invert",
+    "ior",
+    "ipow",
+    "irshift",
+    "is_",
+    "is_not",
+    "isub",
+    "itemgetter",
+    "itruediv",
+    "ixor",
+    "le",
+    "length_hint",
+    "lshift",
+    "lt",
+    "matmul",
+    "methodcaller",
+    "mod",
+    "mul",
+    "ne",
+    "neg",
+    "not_",
+    "or_",
+    "pos",
+    "pow",
+    "rshift",
+    "setitem",
+    "sub",
+    "truediv",
+    "truth",
+    "xor",
+]
+
+if sys.version_info >= (3, 11):
+    __all__ += ["call"]
+
+__lt__ = lt
+__le__ = le
+__eq__ = eq
+__ne__ = ne
+__ge__ = ge
+__gt__ = gt
+__not__ = not_
+__abs__ = abs
+__add__ = add
+__and__ = and_
+__floordiv__ = floordiv
+__index__ = index
+__inv__ = inv
+__invert__ = invert
+__lshift__ = lshift
+__mod__ = mod
+__mul__ = mul
+__matmul__ = matmul
+__neg__ = neg
+__or__ = or_
+__pos__ = pos
+__pow__ = pow
+__rshift__ = rshift
+__sub__ = sub
+__truediv__ = truediv
+__xor__ = xor
+__concat__ = concat
+__contains__ = contains
+__delitem__ = delitem
+__getitem__ = getitem
+__setitem__ = setitem
+__iadd__ = iadd
+__iand__ = iand
+__iconcat__ = iconcat
+__ifloordiv__ = ifloordiv
+__ilshift__ = ilshift
+__imod__ = imod
+__imul__ = imul
+__imatmul__ = imatmul
+__ior__ = ior
+__ipow__ = ipow
+__irshift__ = irshift
+__isub__ = isub
+__itruediv__ = itruediv
+__ixor__ = ixor
+if sys.version_info >= (3, 11):
+    __call__ = call