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

mypy/typeshed/stdlib/multiprocessing/reduction.pyi

@@ -0,0 +1,89 @@
+import pickle
+import sys
+from _typeshed import HasFileno, SupportsWrite, Unused
+from abc import ABCMeta
+from builtins import type as Type  # alias to avoid name clash
+from collections.abc import Callable
+from copyreg import _DispatchTableType
+from multiprocessing import connection
+from pickle import _ReducedType
+from socket import socket
+from typing import Any, Literal
+
+if sys.platform == "win32":
+    __all__ = ["send_handle", "recv_handle", "ForkingPickler", "register", "dump", "DupHandle", "duplicate", "steal_handle"]
+else:
+    __all__ = ["send_handle", "recv_handle", "ForkingPickler", "register", "dump", "DupFd", "sendfds", "recvfds"]
+
+HAVE_SEND_HANDLE: bool
+
+class ForkingPickler(pickle.Pickler):
+    dispatch_table: _DispatchTableType
+    def __init__(self, file: SupportsWrite[bytes], protocol: int | None = ...) -> None: ...
+    @classmethod
+    def register(cls, type: Type, reduce: Callable[[Any], _ReducedType]) -> None: ...
+    @classmethod
+    def dumps(cls, obj: Any, protocol: int | None = None) -> memoryview: ...
+    loads = pickle.loads
+
+register = ForkingPickler.register
+
+def dump(obj: Any, file: SupportsWrite[bytes], protocol: int | None = None) -> None: ...
+
+if sys.platform == "win32":
+    def duplicate(
+        handle: int, target_process: int | None = None, inheritable: bool = False, *, source_process: int | None = None
+    ) -> int: ...
+    def steal_handle(source_pid: int, handle: int) -> int: ...
+    def send_handle(conn: connection.PipeConnection, handle: int, destination_pid: int) -> None: ...
+    def recv_handle(conn: connection.PipeConnection) -> int: ...
+
+    class DupHandle:
+        def __init__(self, handle: int, access: int, pid: int | None = None) -> None: ...
+        def detach(self) -> int: ...
+
+else:
+    if sys.platform == "darwin":
+        ACKNOWLEDGE: Literal[True]
+    else:
+        ACKNOWLEDGE: Literal[False]
+
+    def recvfds(sock: socket, size: int) -> list[int]: ...
+    def send_handle(conn: HasFileno, handle: int, destination_pid: Unused) -> None: ...
+    def recv_handle(conn: HasFileno) -> int: ...
+    def sendfds(sock: socket, fds: list[int]) -> None: ...
+    def DupFd(fd: int) -> Any: ...  # Return type is really hard to get right
+
+# These aliases are to work around pyright complaints.
+# Pyright doesn't like it when a class object is defined as an alias
+# of a global object with the same name.
+_ForkingPickler = ForkingPickler
+_register = register
+_dump = dump
+_send_handle = send_handle
+_recv_handle = recv_handle
+
+if sys.platform == "win32":
+    _steal_handle = steal_handle
+    _duplicate = duplicate
+    _DupHandle = DupHandle
+else:
+    _sendfds = sendfds
+    _recvfds = recvfds
+    _DupFd = DupFd
+
+class AbstractReducer(metaclass=ABCMeta):
+    ForkingPickler = _ForkingPickler
+    register = _register
+    dump = _dump
+    send_handle = _send_handle
+    recv_handle = _recv_handle
+    if sys.platform == "win32":
+        steal_handle = _steal_handle
+        duplicate = _duplicate
+        DupHandle = _DupHandle
+    else:
+        sendfds = _sendfds
+        recvfds = _recvfds
+        DupFd = _DupFd
+    def __init__(self, *args: Unused) -> None: ...

mypy/typeshed/stdlib/multiprocessing/resource_sharer.pyi

@@ -0,0 +1,20 @@
+import sys
+from socket import socket
+
+__all__ = ["stop"]
+
+if sys.platform == "win32":
+    __all__ += ["DupSocket"]
+
+    class DupSocket:
+        def __init__(self, sock: socket) -> None: ...
+        def detach(self) -> socket: ...
+
+else:
+    __all__ += ["DupFd"]
+
+    class DupFd:
+        def __init__(self, fd: int) -> None: ...
+        def detach(self) -> int: ...
+
+def stop(timeout: float | None = None) -> None: ...

mypy/typeshed/stdlib/multiprocessing/resource_tracker.pyi

@@ -0,0 +1,18 @@
+from _typeshed import FileDescriptorOrPath, Incomplete
+from collections.abc import Sized
+
+__all__ = ["ensure_running", "register", "unregister"]
+
+class ResourceTracker:
+    def getfd(self) -> int | None: ...
+    def ensure_running(self) -> None: ...
+    def register(self, name: Sized, rtype: Incomplete) -> None: ...
+    def unregister(self, name: Sized, rtype: Incomplete) -> None: ...
+
+_resource_tracker: ResourceTracker
+ensure_running = _resource_tracker.ensure_running
+register = _resource_tracker.register
+unregister = _resource_tracker.unregister
+getfd = _resource_tracker.getfd
+
+def main(fd: FileDescriptorOrPath) -> None: ...

mypy/typeshed/stdlib/multiprocessing/shared_memory.pyi

@@ -0,0 +1,40 @@
+import sys
+from collections.abc import Iterable
+from typing import Any, Generic, TypeVar, overload
+from typing_extensions import Self
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+__all__ = ["SharedMemory", "ShareableList"]
+
+_SLT = TypeVar("_SLT", int, float, bool, str, bytes, None)
+
+class SharedMemory:
+    def __init__(self, name: str | None = None, create: bool = False, size: int = 0) -> None: ...
+    @property
+    def buf(self) -> memoryview: ...
+    @property
+    def name(self) -> str: ...
+    @property
+    def size(self) -> int: ...
+    def close(self) -> None: ...
+    def unlink(self) -> None: ...
+    def __del__(self) -> None: ...
+
+class ShareableList(Generic[_SLT]):
+    shm: SharedMemory
+    @overload
+    def __init__(self, sequence: None = None, *, name: str | None = None) -> None: ...
+    @overload
+    def __init__(self, sequence: Iterable[_SLT], *, name: str | None = None) -> None: ...
+    def __getitem__(self, position: int) -> _SLT: ...
+    def __setitem__(self, position: int, value: _SLT) -> None: ...
+    def __reduce__(self) -> tuple[Self, tuple[_SLT, ...]]: ...
+    def __len__(self) -> int: ...
+    @property
+    def format(self) -> str: ...
+    def count(self, value: _SLT) -> int: ...
+    def index(self, value: _SLT) -> int: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...

mypy/typeshed/stdlib/multiprocessing/sharedctypes.pyi

@@ -0,0 +1,101 @@
+import ctypes
+from collections.abc import Callable, Iterable, Sequence
+from ctypes import _CData, _SimpleCData, c_char
+from multiprocessing.context import BaseContext
+from multiprocessing.synchronize import _LockLike
+from types import TracebackType
+from typing import Any, Generic, Literal, Protocol, TypeVar, overload
+
+__all__ = ["RawValue", "RawArray", "Value", "Array", "copy", "synchronized"]
+
+_T = TypeVar("_T")
+_CT = TypeVar("_CT", bound=_CData)
+
+@overload
+def RawValue(typecode_or_type: type[_CT], *args: Any) -> _CT: ...
+@overload
+def RawValue(typecode_or_type: str, *args: Any) -> Any: ...
+@overload
+def RawArray(typecode_or_type: type[_CT], size_or_initializer: int | Sequence[Any]) -> ctypes.Array[_CT]: ...
+@overload
+def RawArray(typecode_or_type: str, size_or_initializer: int | Sequence[Any]) -> Any: ...
+@overload
+def Value(typecode_or_type: type[_CT], *args: Any, lock: Literal[False], ctx: BaseContext | None = None) -> _CT: ...
+@overload
+def Value(
+    typecode_or_type: type[_CT], *args: Any, lock: Literal[True] | _LockLike = True, ctx: BaseContext | None = None
+) -> SynchronizedBase[_CT]: ...
+@overload
+def Value(
+    typecode_or_type: str, *args: Any, lock: Literal[True] | _LockLike = True, ctx: BaseContext | None = None
+) -> SynchronizedBase[Any]: ...
+@overload
+def Value(
+    typecode_or_type: str | type[_CData], *args: Any, lock: bool | _LockLike = True, ctx: BaseContext | None = None
+) -> Any: ...
+@overload
+def Array(
+    typecode_or_type: type[_CT], size_or_initializer: int | Sequence[Any], *, lock: Literal[False], ctx: BaseContext | None = None
+) -> _CT: ...
+@overload
+def Array(
+    typecode_or_type: type[_CT],
+    size_or_initializer: int | Sequence[Any],
+    *,
+    lock: Literal[True] | _LockLike = True,
+    ctx: BaseContext | None = None,
+) -> SynchronizedArray[_CT]: ...
+@overload
+def Array(
+    typecode_or_type: str,
+    size_or_initializer: int | Sequence[Any],
+    *,
+    lock: Literal[True] | _LockLike = True,
+    ctx: BaseContext | None = None,
+) -> SynchronizedArray[Any]: ...
+@overload
+def Array(
+    typecode_or_type: str | type[_CData],
+    size_or_initializer: int | Sequence[Any],
+    *,
+    lock: bool | _LockLike = True,
+    ctx: BaseContext | None = None,
+) -> Any: ...
+def copy(obj: _CT) -> _CT: ...
+@overload
+def synchronized(obj: _SimpleCData[_T], lock: _LockLike | None = None, ctx: Any | None = None) -> Synchronized[_T]: ...
+@overload
+def synchronized(obj: ctypes.Array[c_char], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedString: ...
+@overload
+def synchronized(obj: ctypes.Array[_CT], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedArray[_CT]: ...
+@overload
+def synchronized(obj: _CT, lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedBase[_CT]: ...
+
+class _AcquireFunc(Protocol):
+    def __call__(self, __block: bool = ..., __timeout: float | None = ...) -> bool: ...
+
+class SynchronizedBase(Generic[_CT]):
+    acquire: _AcquireFunc
+    release: Callable[[], None]
+    def __init__(self, obj: Any, lock: _LockLike | None = None, ctx: Any | None = None) -> None: ...
+    def __reduce__(self) -> tuple[Callable[[Any, _LockLike], SynchronizedBase[Any]], tuple[Any, _LockLike]]: ...
+    def get_obj(self) -> _CT: ...
+    def get_lock(self) -> _LockLike: ...
+    def __enter__(self) -> bool: ...
+    def __exit__(
+        self, __exc_type: type[BaseException] | None, __exc_val: BaseException | None, __exc_tb: TracebackType | None
+    ) -> None: ...
+
+class Synchronized(SynchronizedBase[_SimpleCData[_T]], Generic[_T]):
+    value: _T
+
+class SynchronizedArray(SynchronizedBase[ctypes.Array[_CT]], Generic[_CT]):
+    def __len__(self) -> int: ...
+    def __getitem__(self, i: int) -> _CT: ...
+    def __setitem__(self, i: int, value: _CT) -> None: ...
+    def __getslice__(self, start: int, stop: int) -> list[_CT]: ...
+    def __setslice__(self, start: int, stop: int, values: Iterable[_CT]) -> None: ...
+
+class SynchronizedString(SynchronizedArray[c_char]):
+    value: bytes
+    raw: bytes

mypy/typeshed/stdlib/multiprocessing/spawn.pyi

@@ -0,0 +1,32 @@
+from collections.abc import Mapping, Sequence
+from types import ModuleType
+from typing import Any
+
+__all__ = [
+    "_main",
+    "freeze_support",
+    "set_executable",
+    "get_executable",
+    "get_preparation_data",
+    "get_command_line",
+    "import_main_path",
+]
+
+WINEXE: bool
+WINSERVICE: bool
+
+def set_executable(exe: str) -> None: ...
+def get_executable() -> str: ...
+def is_forking(argv: Sequence[str]) -> bool: ...
+def freeze_support() -> None: ...
+def get_command_line(**kwds: Any) -> list[str]: ...
+def spawn_main(pipe_handle: int, parent_pid: int | None = None, tracker_fd: int | None = None) -> None: ...
+
+# undocumented
+def _main(fd: int) -> Any: ...
+def get_preparation_data(name: str) -> dict[str, Any]: ...
+
+old_main_modules: list[ModuleType]
+
+def prepare(data: Mapping[str, Any]) -> None: ...
+def import_main_path(main_path: str) -> None: ...

mypy/typeshed/stdlib/multiprocessing/synchronize.pyi

@@ -0,0 +1,54 @@
+import threading
+from collections.abc import Callable
+from contextlib import AbstractContextManager
+from multiprocessing.context import BaseContext
+from types import TracebackType
+from typing_extensions import TypeAlias
+
+__all__ = ["Lock", "RLock", "Semaphore", "BoundedSemaphore", "Condition", "Event"]
+
+_LockLike: TypeAlias = Lock | RLock
+
+class Barrier(threading.Barrier):
+    def __init__(
+        self, parties: int, action: Callable[[], object] | None = None, timeout: float | None = None, *ctx: BaseContext
+    ) -> None: ...
+
+class Condition(AbstractContextManager[bool]):
+    def __init__(self, lock: _LockLike | None = None, *, ctx: BaseContext) -> None: ...
+    def notify(self, n: int = 1) -> None: ...
+    def notify_all(self) -> None: ...
+    def wait(self, timeout: float | None = None) -> bool: ...
+    def wait_for(self, predicate: Callable[[], bool], timeout: float | None = None) -> bool: ...
+    def acquire(self, block: bool = ..., timeout: float | None = ...) -> bool: ...
+    def release(self) -> None: ...
+    def __exit__(
+        self, __exc_type: type[BaseException] | None, __exc_val: BaseException | None, __exc_tb: TracebackType | None
+    ) -> None: ...
+
+class Event:
+    def __init__(self, *, ctx: BaseContext) -> None: ...
+    def is_set(self) -> bool: ...
+    def set(self) -> None: ...
+    def clear(self) -> None: ...
+    def wait(self, timeout: float | None = None) -> bool: ...
+
+# Not part of public API
+class SemLock(AbstractContextManager[bool]):
+    def acquire(self, block: bool = ..., timeout: float | None = ...) -> bool: ...
+    def release(self) -> None: ...
+    def __exit__(
+        self, __exc_type: type[BaseException] | None, __exc_val: BaseException | None, __exc_tb: TracebackType | None
+    ) -> None: ...
+
+class Lock(SemLock):
+    def __init__(self, *, ctx: BaseContext) -> None: ...
+
+class RLock(SemLock):
+    def __init__(self, *, ctx: BaseContext) -> None: ...
+
+class Semaphore(SemLock):
+    def __init__(self, value: int = 1, *, ctx: BaseContext) -> None: ...
+
+class BoundedSemaphore(Semaphore):
+    def __init__(self, value: int = 1, *, ctx: BaseContext) -> None: ...

mypy/typeshed/stdlib/multiprocessing/util.pyi

@@ -0,0 +1,79 @@
+import threading
+from _typeshed import ConvertibleToInt, Incomplete, Unused
+from collections.abc import Callable, Iterable, Mapping, MutableMapping, Sequence
+from logging import Logger, _Level as _LoggingLevel
+from typing import Any
+
+__all__ = [
+    "sub_debug",
+    "debug",
+    "info",
+    "sub_warning",
+    "get_logger",
+    "log_to_stderr",
+    "get_temp_dir",
+    "register_after_fork",
+    "is_exiting",
+    "Finalize",
+    "ForkAwareThreadLock",
+    "ForkAwareLocal",
+    "close_all_fds_except",
+    "SUBDEBUG",
+    "SUBWARNING",
+]
+
+NOTSET: int
+SUBDEBUG: int
+DEBUG: int
+INFO: int
+SUBWARNING: int
+
+LOGGER_NAME: str
+DEFAULT_LOGGING_FORMAT: str
+
+def sub_debug(msg: object, *args: object) -> None: ...
+def debug(msg: object, *args: object) -> None: ...
+def info(msg: object, *args: object) -> None: ...
+def sub_warning(msg: object, *args: object) -> None: ...
+def get_logger() -> Logger: ...
+def log_to_stderr(level: _LoggingLevel | None = None) -> Logger: ...
+def is_abstract_socket_namespace(address: str | bytes | None) -> bool: ...
+
+abstract_sockets_supported: bool
+
+def get_temp_dir() -> str: ...
+def register_after_fork(obj: Incomplete, func: Callable[[Incomplete], object]) -> None: ...
+
+class Finalize:
+    def __init__(
+        self,
+        obj: Incomplete | None,
+        callback: Callable[..., Incomplete],
+        args: Sequence[Any] = (),
+        kwargs: Mapping[str, Any] | None = None,
+        exitpriority: int | None = None,
+    ) -> None: ...
+    def __call__(
+        self,
+        wr: Unused = None,
+        _finalizer_registry: MutableMapping[Incomplete, Incomplete] = {},
+        sub_debug: Callable[..., object] = ...,
+        getpid: Callable[[], int] = ...,
+    ) -> Incomplete: ...
+    def cancel(self) -> None: ...
+    def still_active(self) -> bool: ...
+
+def is_exiting() -> bool: ...
+
+class ForkAwareThreadLock:
+    acquire: Callable[[bool, float], bool]
+    release: Callable[[], None]
+    def __enter__(self) -> bool: ...
+    def __exit__(self, *args: Unused) -> None: ...
+
+class ForkAwareLocal(threading.local): ...
+
+MAXFD: int
+
+def close_all_fds_except(fds: Iterable[int]) -> None: ...
+def spawnv_passfds(path: bytes, args: Sequence[ConvertibleToInt], passfds: Sequence[int]) -> int: ...

mypy/typeshed/stdlib/netrc.pyi

@@ -0,0 +1,23 @@
+import sys
+from _typeshed import StrOrBytesPath
+from typing_extensions import TypeAlias
+
+__all__ = ["netrc", "NetrcParseError"]
+
+class NetrcParseError(Exception):
+    filename: str | None
+    lineno: int | None
+    msg: str
+    def __init__(self, msg: str, filename: StrOrBytesPath | None = None, lineno: int | None = None) -> None: ...
+
+# (login, account, password) tuple
+if sys.version_info >= (3, 11):
+    _NetrcTuple: TypeAlias = tuple[str, str, str]
+else:
+    _NetrcTuple: TypeAlias = tuple[str, str | None, str | None]
+
+class netrc:
+    hosts: dict[str, _NetrcTuple]
+    macros: dict[str, list[str]]
+    def __init__(self, file: StrOrBytesPath | None = None) -> None: ...
+    def authenticators(self, host: str) -> _NetrcTuple | None: ...

mypy/typeshed/stdlib/nis.pyi

@@ -0,0 +1,9 @@
+import sys
+
+if sys.platform != "win32":
+    def cat(map: str, domain: str = ...) -> dict[str, str]: ...
+    def get_default_domain() -> str: ...
+    def maps(domain: str = ...) -> list[str]: ...
+    def match(key: str, map: str, domain: str = ...) -> str: ...
+
+    class error(Exception): ...

mypy/typeshed/stdlib/nntplib.pyi

@@ -0,0 +1,125 @@
+import datetime
+import socket
+import ssl
+import sys
+from _typeshed import Unused
+from builtins import list as _list  # conflicts with a method named "list"
+from collections.abc import Iterable
+from typing import IO, Any, Literal, NamedTuple
+from typing_extensions import Self, TypeAlias
+
+__all__ = [
+    "NNTP",
+    "NNTPError",
+    "NNTPReplyError",
+    "NNTPTemporaryError",
+    "NNTPPermanentError",
+    "NNTPProtocolError",
+    "NNTPDataError",
+    "decode_header",
+    "NNTP_SSL",
+]
+
+_File: TypeAlias = IO[bytes] | bytes | str | None
+
+class NNTPError(Exception):
+    response: str
+
+class NNTPReplyError(NNTPError): ...
+class NNTPTemporaryError(NNTPError): ...
+class NNTPPermanentError(NNTPError): ...
+class NNTPProtocolError(NNTPError): ...
+class NNTPDataError(NNTPError): ...
+
+NNTP_PORT: Literal[119]
+NNTP_SSL_PORT: Literal[563]
+
+class GroupInfo(NamedTuple):
+    group: str
+    last: str
+    first: str
+    flag: str
+
+class ArticleInfo(NamedTuple):
+    number: int
+    message_id: str
+    lines: list[bytes]
+
+def decode_header(header_str: str) -> str: ...
+
+class NNTP:
+    encoding: str
+    errors: str
+
+    host: str
+    port: int
+    sock: socket.socket
+    file: IO[bytes]
+    debugging: int
+    welcome: str
+    readermode_afterauth: bool
+    tls_on: bool
+    authenticated: bool
+    nntp_implementation: str
+    nntp_version: int
+    def __init__(
+        self,
+        host: str,
+        port: int = 119,
+        user: str | None = None,
+        password: str | None = None,
+        readermode: bool | None = None,
+        usenetrc: bool = False,
+        timeout: float = ...,
+    ) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(self, *args: Unused) -> None: ...
+    def getwelcome(self) -> str: ...
+    def getcapabilities(self) -> dict[str, _list[str]]: ...
+    def set_debuglevel(self, level: int) -> None: ...
+    def debug(self, level: int) -> None: ...
+    def capabilities(self) -> tuple[str, dict[str, _list[str]]]: ...
+    def newgroups(self, date: datetime.date | datetime.datetime, *, file: _File = None) -> tuple[str, _list[str]]: ...
+    def newnews(self, group: str, date: datetime.date | datetime.datetime, *, file: _File = None) -> tuple[str, _list[str]]: ...
+    def list(self, group_pattern: str | None = None, *, file: _File = None) -> tuple[str, _list[str]]: ...
+    def description(self, group: str) -> str: ...
+    def descriptions(self, group_pattern: str) -> tuple[str, dict[str, str]]: ...
+    def group(self, name: str) -> tuple[str, int, int, int, str]: ...
+    def help(self, *, file: _File = None) -> tuple[str, _list[str]]: ...
+    def stat(self, message_spec: Any = None) -> tuple[str, int, str]: ...
+    def next(self) -> tuple[str, int, str]: ...
+    def last(self) -> tuple[str, int, str]: ...
+    def head(self, message_spec: Any = None, *, file: _File = None) -> tuple[str, ArticleInfo]: ...
+    def body(self, message_spec: Any = None, *, file: _File = None) -> tuple[str, ArticleInfo]: ...
+    def article(self, message_spec: Any = None, *, file: _File = None) -> tuple[str, ArticleInfo]: ...
+    def slave(self) -> str: ...
+    def xhdr(self, hdr: str, str: Any, *, file: _File = None) -> tuple[str, _list[str]]: ...
+    def xover(self, start: int, end: int, *, file: _File = None) -> tuple[str, _list[tuple[int, dict[str, str]]]]: ...
+    def over(
+        self, message_spec: None | str | _list[Any] | tuple[Any, ...], *, file: _File = None
+    ) -> tuple[str, _list[tuple[int, dict[str, str]]]]: ...
+    if sys.version_info < (3, 9):
+        def xgtitle(self, group: str, *, file: _File = None) -> tuple[str, _list[tuple[str, str]]]: ...
+        def xpath(self, id: Any) -> tuple[str, str]: ...
+
+    def date(self) -> tuple[str, datetime.datetime]: ...
+    def post(self, data: bytes | Iterable[bytes]) -> str: ...
+    def ihave(self, message_id: Any, data: bytes | Iterable[bytes]) -> str: ...
+    def quit(self) -> str: ...
+    def login(self, user: str | None = None, password: str | None = None, usenetrc: bool = True) -> None: ...
+    def starttls(self, context: ssl.SSLContext | None = None) -> None: ...
+
+class NNTP_SSL(NNTP):
+    ssl_context: ssl.SSLContext | None
+    sock: ssl.SSLSocket
+    def __init__(
+        self,
+        host: str,
+        port: int = 563,
+        user: str | None = None,
+        password: str | None = None,
+        ssl_context: ssl.SSLContext | None = None,
+        readermode: bool | None = None,
+        usenetrc: bool = False,
+        timeout: float = ...,
+    ) -> None: ...