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

mypy/typeshed/stdlib/errno.pyi

@@ -0,0 +1,222 @@
+import sys
+from collections.abc import Mapping
+
+errorcode: Mapping[int, str]
+
+EPERM: int
+ENOENT: int
+ESRCH: int
+EINTR: int
+EIO: int
+ENXIO: int
+E2BIG: int
+ENOEXEC: int
+EBADF: int
+ECHILD: int
+EAGAIN: int
+ENOMEM: int
+EACCES: int
+EFAULT: int
+EBUSY: int
+EEXIST: int
+EXDEV: int
+ENODEV: int
+ENOTDIR: int
+EISDIR: int
+EINVAL: int
+ENFILE: int
+EMFILE: int
+ENOTTY: int
+ETXTBSY: int
+EFBIG: int
+ENOSPC: int
+ESPIPE: int
+EROFS: int
+EMLINK: int
+EPIPE: int
+EDOM: int
+ERANGE: int
+EDEADLK: int
+ENAMETOOLONG: int
+ENOLCK: int
+ENOSYS: int
+ENOTEMPTY: int
+ELOOP: int
+EWOULDBLOCK: int
+ENOMSG: int
+EIDRM: int
+ENOSTR: int
+ENODATA: int
+ETIME: int
+ENOSR: int
+EREMOTE: int
+ENOLINK: int
+EPROTO: int
+EBADMSG: int
+EOVERFLOW: int
+EILSEQ: int
+EUSERS: int
+ENOTSOCK: int
+EDESTADDRREQ: int
+EMSGSIZE: int
+EPROTOTYPE: int
+ENOPROTOOPT: int
+EPROTONOSUPPORT: int
+ESOCKTNOSUPPORT: int
+ENOTSUP: int
+EOPNOTSUPP: int
+EPFNOSUPPORT: int
+EAFNOSUPPORT: int
+EADDRINUSE: int
+EADDRNOTAVAIL: int
+ENETDOWN: int
+ENETUNREACH: int
+ENETRESET: int
+ECONNABORTED: int
+ECONNRESET: int
+ENOBUFS: int
+EISCONN: int
+ENOTCONN: int
+ESHUTDOWN: int
+ETOOMANYREFS: int
+ETIMEDOUT: int
+ECONNREFUSED: int
+EHOSTDOWN: int
+EHOSTUNREACH: int
+EALREADY: int
+EINPROGRESS: int
+ESTALE: int
+EDQUOT: int
+ECANCELED: int  # undocumented
+ENOTRECOVERABLE: int  # undocumented
+EOWNERDEAD: int  # undocumented
+
+if sys.platform == "sunos5" or sys.platform == "solaris":  # noqa: Y008
+    ELOCKUNMAPPED: int
+    ENOTACTIVE: int
+
+if sys.platform != "win32":
+    ENOTBLK: int
+    EMULTIHOP: int
+
+if sys.platform == "darwin":
+    # All of the below are undocumented
+    EAUTH: int
+    EBADARCH: int
+    EBADEXEC: int
+    EBADMACHO: int
+    EBADRPC: int
+    EDEVERR: int
+    EFTYPE: int
+    ENEEDAUTH: int
+    ENOATTR: int
+    ENOPOLICY: int
+    EPROCLIM: int
+    EPROCUNAVAIL: int
+    EPROGMISMATCH: int
+    EPROGUNAVAIL: int
+    EPWROFF: int
+    ERPCMISMATCH: int
+    ESHLIBVERS: int
+    if sys.version_info >= (3, 11):
+        EQFULL: int
+
+if sys.platform != "darwin":
+    EDEADLOCK: int
+
+if sys.platform != "win32" and sys.platform != "darwin":
+    ECHRNG: int
+    EL2NSYNC: int
+    EL3HLT: int
+    EL3RST: int
+    ELNRNG: int
+    EUNATCH: int
+    ENOCSI: int
+    EL2HLT: int
+    EBADE: int
+    EBADR: int
+    EXFULL: int
+    ENOANO: int
+    EBADRQC: int
+    EBADSLT: int
+    EBFONT: int
+    ENONET: int
+    ENOPKG: int
+    EADV: int
+    ESRMNT: int
+    ECOMM: int
+    EDOTDOT: int
+    ENOTUNIQ: int
+    EBADFD: int
+    EREMCHG: int
+    ELIBACC: int
+    ELIBBAD: int
+    ELIBSCN: int
+    ELIBMAX: int
+    ELIBEXEC: int
+    ERESTART: int
+    ESTRPIPE: int
+    EUCLEAN: int
+    ENOTNAM: int
+    ENAVAIL: int
+    EISNAM: int
+    EREMOTEIO: int
+    # All of the below are undocumented
+    EKEYEXPIRED: int
+    EKEYREJECTED: int
+    EKEYREVOKED: int
+    EMEDIUMTYPE: int
+    ENOKEY: int
+    ENOMEDIUM: int
+    ERFKILL: int
+
+if sys.platform == "win32":
+    # All of these are undocumented
+    WSABASEERR: int
+    WSAEACCES: int
+    WSAEADDRINUSE: int
+    WSAEADDRNOTAVAIL: int
+    WSAEAFNOSUPPORT: int
+    WSAEALREADY: int
+    WSAEBADF: int
+    WSAECONNABORTED: int
+    WSAECONNREFUSED: int
+    WSAECONNRESET: int
+    WSAEDESTADDRREQ: int
+    WSAEDISCON: int
+    WSAEDQUOT: int
+    WSAEFAULT: int
+    WSAEHOSTDOWN: int
+    WSAEHOSTUNREACH: int
+    WSAEINPROGRESS: int
+    WSAEINTR: int
+    WSAEINVAL: int
+    WSAEISCONN: int
+    WSAELOOP: int
+    WSAEMFILE: int
+    WSAEMSGSIZE: int
+    WSAENAMETOOLONG: int
+    WSAENETDOWN: int
+    WSAENETRESET: int
+    WSAENETUNREACH: int
+    WSAENOBUFS: int
+    WSAENOPROTOOPT: int
+    WSAENOTCONN: int
+    WSAENOTEMPTY: int
+    WSAENOTSOCK: int
+    WSAEOPNOTSUPP: int
+    WSAEPFNOSUPPORT: int
+    WSAEPROCLIM: int
+    WSAEPROTONOSUPPORT: int
+    WSAEPROTOTYPE: int
+    WSAEREMOTE: int
+    WSAESHUTDOWN: int
+    WSAESOCKTNOSUPPORT: int
+    WSAESTALE: int
+    WSAETIMEDOUT: int
+    WSAETOOMANYREFS: int
+    WSAEUSERS: int
+    WSAEWOULDBLOCK: int
+    WSANOTINITIALISED: int
+    WSASYSNOTREADY: int
+    WSAVERNOTSUPPORTED: int

mypy/typeshed/stdlib/faulthandler.pyi

@@ -0,0 +1,13 @@
+import sys
+from _typeshed import FileDescriptorLike
+
+def cancel_dump_traceback_later() -> None: ...
+def disable() -> None: ...
+def dump_traceback(file: FileDescriptorLike = ..., all_threads: bool = ...) -> None: ...
+def dump_traceback_later(timeout: float, repeat: bool = ..., file: FileDescriptorLike = ..., exit: bool = ...) -> None: ...
+def enable(file: FileDescriptorLike = ..., all_threads: bool = ...) -> None: ...
+def is_enabled() -> bool: ...
+
+if sys.platform != "win32":
+    def register(signum: int, file: FileDescriptorLike = ..., all_threads: bool = ..., chain: bool = ...) -> None: ...
+    def unregister(signum: int) -> None: ...

mypy/typeshed/stdlib/fcntl.pyi

@@ -0,0 +1,127 @@
+import sys
+from _typeshed import FileDescriptorLike, ReadOnlyBuffer, WriteableBuffer
+from typing import Any, Literal, overload
+from typing_extensions import Buffer
+
+if sys.platform != "win32":
+    FASYNC: int
+    FD_CLOEXEC: int
+    F_DUPFD: int
+    F_DUPFD_CLOEXEC: int
+    F_GETFD: int
+    F_GETFL: int
+    F_GETLK: int
+    F_GETOWN: int
+    F_RDLCK: int
+    F_SETFD: int
+    F_SETFL: int
+    F_SETLK: int
+    F_SETLKW: int
+    F_SETOWN: int
+    F_UNLCK: int
+    F_WRLCK: int
+
+    F_GETLEASE: int
+    F_SETLEASE: int
+    if sys.platform == "darwin":
+        F_FULLFSYNC: int
+        F_NOCACHE: int
+        if sys.version_info >= (3, 9):
+            F_GETPATH: int
+    if sys.platform == "linux":
+        F_SETLKW64: int
+        F_SETSIG: int
+        F_SHLCK: int
+        F_SETLK64: int
+        F_GETSIG: int
+        F_NOTIFY: int
+        F_EXLCK: int
+        F_GETLK64: int
+        F_ADD_SEALS: int
+        F_GET_SEALS: int
+        F_SEAL_GROW: int
+        F_SEAL_SEAL: int
+        F_SEAL_SHRINK: int
+        F_SEAL_WRITE: int
+        if sys.version_info >= (3, 9):
+            F_OFD_GETLK: int
+            F_OFD_SETLK: int
+            F_OFD_SETLKW: int
+        if sys.version_info >= (3, 10):
+            F_GETPIPE_SZ: int
+            F_SETPIPE_SZ: int
+
+        DN_ACCESS: int
+        DN_ATTRIB: int
+        DN_CREATE: int
+        DN_DELETE: int
+        DN_MODIFY: int
+        DN_MULTISHOT: int
+        DN_RENAME: int
+
+    LOCK_EX: int
+    LOCK_NB: int
+    LOCK_SH: int
+    LOCK_UN: int
+    if sys.platform == "linux":
+        LOCK_MAND: int
+        LOCK_READ: int
+        LOCK_RW: int
+        LOCK_WRITE: int
+
+    # These are highly problematic, they might be present or not, depends on the specific OS.
+    if sys.platform == "linux":
+        I_ATMARK: int
+        I_CANPUT: int
+        I_CKBAND: int
+        I_FDINSERT: int
+        I_FIND: int
+        I_FLUSH: int
+        I_FLUSHBAND: int
+        I_GETBAND: int
+        I_GETCLTIME: int
+        I_GETSIG: int
+        I_GRDOPT: int
+        I_GWROPT: int
+        I_LINK: int
+        I_LIST: int
+        I_LOOK: int
+        I_NREAD: int
+        I_PEEK: int
+        I_PLINK: int
+        I_POP: int
+        I_PUNLINK: int
+        I_PUSH: int
+        I_RECVFD: int
+        I_SENDFD: int
+        I_SETCLTIME: int
+        I_SETSIG: int
+        I_SRDOPT: int
+        I_STR: int
+        I_SWROPT: int
+        I_UNLINK: int
+
+    if sys.version_info >= (3, 12) and sys.platform == "linux":
+        FICLONE: int
+        FICLONERANGE: int
+
+    @overload
+    def fcntl(__fd: FileDescriptorLike, __cmd: int, __arg: int = 0) -> int: ...
+    @overload
+    def fcntl(__fd: FileDescriptorLike, __cmd: int, __arg: str | ReadOnlyBuffer) -> bytes: ...
+    # If arg is an int, return int
+    @overload
+    def ioctl(__fd: FileDescriptorLike, __request: int, __arg: int = 0, __mutate_flag: bool = True) -> int: ...
+    # The return type works as follows:
+    # - If arg is a read-write buffer, return int if mutate_flag is True, otherwise bytes
+    # - If arg is a read-only buffer, return bytes (and ignore the value of mutate_flag)
+    # We can't represent that precisely as we can't distinguish between read-write and read-only
+    # buffers, so we add overloads for a few unambiguous cases and use Any for the rest.
+    @overload
+    def ioctl(__fd: FileDescriptorLike, __request: int, __arg: bytes, __mutate_flag: bool = True) -> bytes: ...
+    @overload
+    def ioctl(__fd: FileDescriptorLike, __request: int, __arg: WriteableBuffer, __mutate_flag: Literal[False]) -> bytes: ...
+    @overload
+    def ioctl(__fd: FileDescriptorLike, __request: int, __arg: Buffer, __mutate_flag: bool = True) -> Any: ...
+    def flock(__fd: FileDescriptorLike, __operation: int) -> None: ...
+    def lockf(__fd: FileDescriptorLike, __cmd: int, __len: int = 0, __start: int = 0, __whence: int = 0) -> Any: ...

mypy/typeshed/stdlib/filecmp.pyi

@@ -0,0 +1,57 @@
+import sys
+from _typeshed import GenericPath, StrOrBytesPath
+from collections.abc import Callable, Iterable, Sequence
+from typing import Any, AnyStr, Generic, Literal
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+__all__ = ["clear_cache", "cmp", "dircmp", "cmpfiles", "DEFAULT_IGNORES"]
+
+DEFAULT_IGNORES: list[str]
+BUFSIZE: Literal[8192]
+
+def cmp(f1: StrOrBytesPath, f2: StrOrBytesPath, shallow: bool | Literal[0, 1] = True) -> bool: ...
+def cmpfiles(
+    a: GenericPath[AnyStr], b: GenericPath[AnyStr], common: Iterable[GenericPath[AnyStr]], shallow: bool | Literal[0, 1] = True
+) -> tuple[list[AnyStr], list[AnyStr], list[AnyStr]]: ...
+
+class dircmp(Generic[AnyStr]):
+    def __init__(
+        self,
+        a: GenericPath[AnyStr],
+        b: GenericPath[AnyStr],
+        ignore: Sequence[AnyStr] | None = None,
+        hide: Sequence[AnyStr] | None = None,
+    ) -> None: ...
+    left: AnyStr
+    right: AnyStr
+    hide: Sequence[AnyStr]
+    ignore: Sequence[AnyStr]
+    # These properties are created at runtime by __getattr__
+    subdirs: dict[AnyStr, dircmp[AnyStr]]
+    same_files: list[AnyStr]
+    diff_files: list[AnyStr]
+    funny_files: list[AnyStr]
+    common_dirs: list[AnyStr]
+    common_files: list[AnyStr]
+    common_funny: list[AnyStr]
+    common: list[AnyStr]
+    left_only: list[AnyStr]
+    right_only: list[AnyStr]
+    left_list: list[AnyStr]
+    right_list: list[AnyStr]
+    def report(self) -> None: ...
+    def report_partial_closure(self) -> None: ...
+    def report_full_closure(self) -> None: ...
+    methodmap: dict[str, Callable[[], None]]
+    def phase0(self) -> None: ...
+    def phase1(self) -> None: ...
+    def phase2(self) -> None: ...
+    def phase3(self) -> None: ...
+    def phase4(self) -> None: ...
+    def phase4_closure(self) -> None: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+def clear_cache() -> None: ...

mypy/typeshed/stdlib/fileinput.pyi

@@ -0,0 +1,213 @@
+import sys
+from _typeshed import AnyStr_co, StrOrBytesPath
+from collections.abc import Callable, Iterable, Iterator
+from types import TracebackType
+from typing import IO, Any, AnyStr, Literal, Protocol, overload
+from typing_extensions import Self, TypeAlias
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+__all__ = [
+    "input",
+    "close",
+    "nextfile",
+    "filename",
+    "lineno",
+    "filelineno",
+    "fileno",
+    "isfirstline",
+    "isstdin",
+    "FileInput",
+    "hook_compressed",
+    "hook_encoded",
+]
+
+if sys.version_info >= (3, 11):
+    _TextMode: TypeAlias = Literal["r"]
+else:
+    _TextMode: TypeAlias = Literal["r", "rU", "U"]
+
+class _HasReadlineAndFileno(Protocol[AnyStr_co]):
+    def readline(self) -> AnyStr_co: ...
+    def fileno(self) -> int: ...
+
+if sys.version_info >= (3, 10):
+    # encoding and errors are added
+    @overload
+    def input(
+        files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
+        inplace: bool = False,
+        backup: str = "",
+        *,
+        mode: _TextMode = "r",
+        openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[str]] | None = None,
+        encoding: str | None = None,
+        errors: str | None = None,
+    ) -> FileInput[str]: ...
+    @overload
+    def input(
+        files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
+        inplace: bool = False,
+        backup: str = "",
+        *,
+        mode: Literal["rb"],
+        openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[bytes]] | None = None,
+        encoding: None = None,
+        errors: None = None,
+    ) -> FileInput[bytes]: ...
+    @overload
+    def input(
+        files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
+        inplace: bool = False,
+        backup: str = "",
+        *,
+        mode: str,
+        openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[Any]] | None = None,
+        encoding: str | None = None,
+        errors: str | None = None,
+    ) -> FileInput[Any]: ...
+
+else:
+    # bufsize is dropped and mode and openhook become keyword-only
+    @overload
+    def input(
+        files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
+        inplace: bool = False,
+        backup: str = "",
+        *,
+        mode: _TextMode = "r",
+        openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[str]] | None = None,
+    ) -> FileInput[str]: ...
+    @overload
+    def input(
+        files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
+        inplace: bool = False,
+        backup: str = "",
+        *,
+        mode: Literal["rb"],
+        openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[bytes]] | None = None,
+    ) -> FileInput[bytes]: ...
+    @overload
+    def input(
+        files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
+        inplace: bool = False,
+        backup: str = "",
+        *,
+        mode: str,
+        openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[Any]] | None = None,
+    ) -> FileInput[Any]: ...
+
+def close() -> None: ...
+def nextfile() -> None: ...
+def filename() -> str: ...
+def lineno() -> int: ...
+def filelineno() -> int: ...
+def fileno() -> int: ...
+def isfirstline() -> bool: ...
+def isstdin() -> bool: ...
+
+class FileInput(Iterator[AnyStr]):
+    if sys.version_info >= (3, 10):
+        # encoding and errors are added
+        @overload
+        def __init__(
+            self: FileInput[str],
+            files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
+            inplace: bool = False,
+            backup: str = "",
+            *,
+            mode: _TextMode = "r",
+            openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[str]] | None = None,
+            encoding: str | None = None,
+            errors: str | None = None,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: FileInput[bytes],
+            files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
+            inplace: bool = False,
+            backup: str = "",
+            *,
+            mode: Literal["rb"],
+            openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[bytes]] | None = None,
+            encoding: None = None,
+            errors: None = None,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: FileInput[Any],
+            files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
+            inplace: bool = False,
+            backup: str = "",
+            *,
+            mode: str,
+            openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[Any]] | None = None,
+            encoding: str | None = None,
+            errors: str | None = None,
+        ) -> None: ...
+
+    else:
+        # bufsize is dropped and mode and openhook become keyword-only
+        @overload
+        def __init__(
+            self: FileInput[str],
+            files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
+            inplace: bool = False,
+            backup: str = "",
+            *,
+            mode: _TextMode = "r",
+            openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[str]] | None = None,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: FileInput[bytes],
+            files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
+            inplace: bool = False,
+            backup: str = "",
+            *,
+            mode: Literal["rb"],
+            openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[bytes]] | None = None,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: FileInput[Any],
+            files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
+            inplace: bool = False,
+            backup: str = "",
+            *,
+            mode: str,
+            openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[Any]] | None = None,
+        ) -> None: ...
+
+    def __del__(self) -> None: ...
+    def close(self) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
+    ) -> None: ...
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> AnyStr: ...
+    if sys.version_info < (3, 11):
+        def __getitem__(self, i: int) -> AnyStr: ...
+
+    def nextfile(self) -> None: ...
+    def readline(self) -> AnyStr: ...
+    def filename(self) -> str: ...
+    def lineno(self) -> int: ...
+    def filelineno(self) -> int: ...
+    def fileno(self) -> int: ...
+    def isfirstline(self) -> bool: ...
+    def isstdin(self) -> bool: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+if sys.version_info >= (3, 10):
+    def hook_compressed(
+        filename: StrOrBytesPath, mode: str, *, encoding: str | None = None, errors: str | None = None
+    ) -> IO[Any]: ...
+
+else:
+    def hook_compressed(filename: StrOrBytesPath, mode: str) -> IO[Any]: ...
+
+def hook_encoded(encoding: str, errors: str | None = None) -> Callable[[StrOrBytesPath, str], IO[Any]]: ...

mypy/typeshed/stdlib/fnmatch.pyi

@@ -0,0 +1,9 @@
+from collections.abc import Iterable
+from typing import AnyStr
+
+__all__ = ["filter", "fnmatch", "fnmatchcase", "translate"]
+
+def fnmatch(name: AnyStr, pat: AnyStr) -> bool: ...
+def fnmatchcase(name: AnyStr, pat: AnyStr) -> bool: ...
+def filter(names: Iterable[AnyStr], pat: AnyStr) -> list[AnyStr]: ...
+def translate(pat: str) -> str: ...