basedpyright 1.1.389 → 1.1.392

package/dist/typeshed-fallback/stdlib/multiprocessing/pool.pyi

@@ -1,109 +1,109 @@
-import sys
-from collections.abc import Callable, Iterable, Mapping
-from types import TracebackType
-from typing import Any, Final, Generic, TypeVar
-from typing_extensions import Self
-
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
-__all__ = ["Pool", "ThreadPool"]
-
-_S = TypeVar("_S")
-_T = TypeVar("_T")
-
-class ApplyResult(Generic[_T]):
-    def __init__(
-        self, pool: Pool, callback: Callable[[_T], object] | None, error_callback: Callable[[BaseException], object] | None
-    ) -> None: ...
-    def get(self, timeout: float | None = None) -> _T: ...
-    def wait(self, timeout: float | None = None) -> None: ...
-    def ready(self) -> bool: ...
-    def successful(self) -> bool: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
-            """
-            Represent a PEP 585 generic type
-
-            E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
-            """
-            ...
-
-# alias created during issue #17805
-AsyncResult = ApplyResult
-
-class MapResult(ApplyResult[list[_T]]):
-    def __init__(
-        self,
-        pool: Pool,
-        chunksize: int,
-        length: int,
-        callback: Callable[[list[_T]], object] | None,
-        error_callback: Callable[[BaseException], object] | None,
-    ) -> None: ...
-
-class IMapIterator(Generic[_T]):
-    def __init__(self, pool: Pool) -> None: ...
-    def __iter__(self) -> Self: ...
-    def next(self, timeout: float | None = None) -> _T: ...
-    def __next__(self, timeout: float | None = None) -> _T: ...
-
-class IMapUnorderedIterator(IMapIterator[_T]): ...
-
-class Pool:
-    def __init__(
-        self,
-        processes: int | None = None,
-        initializer: Callable[..., object] | None = None,
-        initargs: Iterable[Any] = (),
-        maxtasksperchild: int | None = None,
-        context: Any | None = None,
-    ) -> None: ...
-    def apply(self, func: Callable[..., _T], args: Iterable[Any] = (), kwds: Mapping[str, Any] = {}) -> _T: ...
-    def apply_async(
-        self,
-        func: Callable[..., _T],
-        args: Iterable[Any] = (),
-        kwds: Mapping[str, Any] = {},
-        callback: Callable[[_T], object] | None = None,
-        error_callback: Callable[[BaseException], object] | None = None,
-    ) -> AsyncResult[_T]: ...
-    def map(self, func: Callable[[_S], _T], iterable: Iterable[_S], chunksize: int | None = None) -> list[_T]: ...
-    def map_async(
-        self,
-        func: Callable[[_S], _T],
-        iterable: Iterable[_S],
-        chunksize: int | None = None,
-        callback: Callable[[list[_T]], object] | None = None,
-        error_callback: Callable[[BaseException], object] | None = None,
-    ) -> MapResult[_T]: ...
-    def imap(self, func: Callable[[_S], _T], iterable: Iterable[_S], chunksize: int | None = 1) -> IMapIterator[_T]: ...
-    def imap_unordered(self, func: Callable[[_S], _T], iterable: Iterable[_S], chunksize: int | None = 1) -> IMapIterator[_T]: ...
-    def starmap(self, func: Callable[..., _T], iterable: Iterable[Iterable[Any]], chunksize: int | None = None) -> list[_T]: ...
-    def starmap_async(
-        self,
-        func: Callable[..., _T],
-        iterable: Iterable[Iterable[Any]],
-        chunksize: int | None = None,
-        callback: Callable[[list[_T]], object] | None = None,
-        error_callback: Callable[[BaseException], object] | None = None,
-    ) -> AsyncResult[list[_T]]: ...
-    def close(self) -> None: ...
-    def terminate(self) -> None: ...
-    def join(self) -> None: ...
-    def __enter__(self) -> Self: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
-    ) -> None: ...
-    def __del__(self) -> None: ...
-
-class ThreadPool(Pool):
-    def __init__(
-        self, processes: int | None = None, initializer: Callable[..., object] | None = None, initargs: Iterable[Any] = ()
-    ) -> None: ...
-
-# undocumented
-INIT: Final = "INIT"
-RUN: Final = "RUN"
-CLOSE: Final = "CLOSE"
-TERMINATE: Final = "TERMINATE"
+import sys
+from collections.abc import Callable, Iterable, Mapping
+from types import TracebackType
+from typing import Any, Final, Generic, TypeVar
+from typing_extensions import Self
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+__all__ = ["Pool", "ThreadPool"]
+
+_S = TypeVar("_S")
+_T = TypeVar("_T")
+
+class ApplyResult(Generic[_T]):
+    def __init__(
+        self, pool: Pool, callback: Callable[[_T], object] | None, error_callback: Callable[[BaseException], object] | None
+    ) -> None: ...
+    def get(self, timeout: float | None = None) -> _T: ...
+    def wait(self, timeout: float | None = None) -> None: ...
+    def ready(self) -> bool: ...
+    def successful(self) -> bool: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+            """
+            Represent a PEP 585 generic type
+
+            E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
+            """
+            ...
+
+# alias created during issue #17805
+AsyncResult = ApplyResult
+
+class MapResult(ApplyResult[list[_T]]):
+    def __init__(
+        self,
+        pool: Pool,
+        chunksize: int,
+        length: int,
+        callback: Callable[[list[_T]], object] | None,
+        error_callback: Callable[[BaseException], object] | None,
+    ) -> None: ...
+
+class IMapIterator(Generic[_T]):
+    def __init__(self, pool: Pool) -> None: ...
+    def __iter__(self) -> Self: ...
+    def next(self, timeout: float | None = None) -> _T: ...
+    def __next__(self, timeout: float | None = None) -> _T: ...
+
+class IMapUnorderedIterator(IMapIterator[_T]): ...
+
+class Pool:
+    def __init__(
+        self,
+        processes: int | None = None,
+        initializer: Callable[..., object] | None = None,
+        initargs: Iterable[Any] = (),
+        maxtasksperchild: int | None = None,
+        context: Any | None = None,
+    ) -> None: ...
+    def apply(self, func: Callable[..., _T], args: Iterable[Any] = (), kwds: Mapping[str, Any] = {}) -> _T: ...
+    def apply_async(
+        self,
+        func: Callable[..., _T],
+        args: Iterable[Any] = (),
+        kwds: Mapping[str, Any] = {},
+        callback: Callable[[_T], object] | None = None,
+        error_callback: Callable[[BaseException], object] | None = None,
+    ) -> AsyncResult[_T]: ...
+    def map(self, func: Callable[[_S], _T], iterable: Iterable[_S], chunksize: int | None = None) -> list[_T]: ...
+    def map_async(
+        self,
+        func: Callable[[_S], _T],
+        iterable: Iterable[_S],
+        chunksize: int | None = None,
+        callback: Callable[[list[_T]], object] | None = None,
+        error_callback: Callable[[BaseException], object] | None = None,
+    ) -> MapResult[_T]: ...
+    def imap(self, func: Callable[[_S], _T], iterable: Iterable[_S], chunksize: int | None = 1) -> IMapIterator[_T]: ...
+    def imap_unordered(self, func: Callable[[_S], _T], iterable: Iterable[_S], chunksize: int | None = 1) -> IMapIterator[_T]: ...
+    def starmap(self, func: Callable[..., _T], iterable: Iterable[Iterable[Any]], chunksize: int | None = None) -> list[_T]: ...
+    def starmap_async(
+        self,
+        func: Callable[..., _T],
+        iterable: Iterable[Iterable[Any]],
+        chunksize: int | None = None,
+        callback: Callable[[list[_T]], object] | None = None,
+        error_callback: Callable[[BaseException], object] | None = None,
+    ) -> AsyncResult[list[_T]]: ...
+    def close(self) -> None: ...
+    def terminate(self) -> None: ...
+    def join(self) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+    ) -> None: ...
+    def __del__(self) -> None: ...
+
+class ThreadPool(Pool):
+    def __init__(
+        self, processes: int | None = None, initializer: Callable[..., object] | None = None, initargs: Iterable[Any] = ()
+    ) -> None: ...
+
+# undocumented
+INIT: Final = "INIT"
+RUN: Final = "RUN"
+CLOSE: Final = "CLOSE"
+TERMINATE: Final = "TERMINATE"

package/dist/typeshed-fallback/stdlib/multiprocessing/process.pyi

@@ -1,50 +1,50 @@
-from collections.abc import Callable, Iterable, Mapping
-from typing import Any
-
-__all__ = ["BaseProcess", "current_process", "active_children", "parent_process"]
-
-class BaseProcess:
-    name: str
-    daemon: bool
-    authkey: bytes
-    _identity: tuple[int, ...]  # undocumented
-    def __init__(
-        self,
-        group: None = None,
-        target: Callable[..., object] | None = None,
-        name: str | None = None,
-        args: Iterable[Any] = (),
-        kwargs: Mapping[str, Any] = {},
-        *,
-        daemon: bool | None = None,
-    ) -> None: ...
-    def run(self) -> None: ...
-    def start(self) -> None: ...
-    def terminate(self) -> None: ...
-    def kill(self) -> None: ...
-    def close(self) -> None: ...
-    def join(self, timeout: float | None = None) -> None: ...
-    def is_alive(self) -> bool: ...
-    @property
-    def exitcode(self) -> int | None:
-        """Return exit code of process or `None` if it has yet to stop"""
-        ...
-    @property
-    def ident(self) -> int | None:
-        """Return identifier (PID) of process or `None` if it has yet to start"""
-        ...
-    @property
-    def pid(self) -> int | None:
-        """Return identifier (PID) of process or `None` if it has yet to start"""
-        ...
-    @property
-    def sentinel(self) -> int:
-        """
-        Return a file descriptor (Unix) or handle (Windows) suitable for
-        waiting for process termination.
-        """
-        ...
-
-def current_process() -> BaseProcess: ...
-def active_children() -> list[BaseProcess]: ...
-def parent_process() -> BaseProcess | None: ...
+from collections.abc import Callable, Iterable, Mapping
+from typing import Any
+
+__all__ = ["BaseProcess", "current_process", "active_children", "parent_process"]
+
+class BaseProcess:
+    name: str
+    daemon: bool
+    authkey: bytes
+    _identity: tuple[int, ...]  # undocumented
+    def __init__(
+        self,
+        group: None = None,
+        target: Callable[..., object] | None = None,
+        name: str | None = None,
+        args: Iterable[Any] = (),
+        kwargs: Mapping[str, Any] = {},
+        *,
+        daemon: bool | None = None,
+    ) -> None: ...
+    def run(self) -> None: ...
+    def start(self) -> None: ...
+    def terminate(self) -> None: ...
+    def kill(self) -> None: ...
+    def close(self) -> None: ...
+    def join(self, timeout: float | None = None) -> None: ...
+    def is_alive(self) -> bool: ...
+    @property
+    def exitcode(self) -> int | None:
+        """Return exit code of process or `None` if it has yet to stop"""
+        ...
+    @property
+    def ident(self) -> int | None:
+        """Return identifier (PID) of process or `None` if it has yet to start"""
+        ...
+    @property
+    def pid(self) -> int | None:
+        """Return identifier (PID) of process or `None` if it has yet to start"""
+        ...
+    @property
+    def sentinel(self) -> int:
+        """
+        Return a file descriptor (Unix) or handle (Windows) suitable for
+        waiting for process termination.
+        """
+        ...
+
+def current_process() -> BaseProcess: ...
+def active_children() -> list[BaseProcess]: ...
+def parent_process() -> BaseProcess | None: ...

package/dist/typeshed-fallback/stdlib/multiprocessing/queues.pyi

@@ -1,53 +1,53 @@
-import sys
-from typing import Any, Generic, TypeVar
-
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
-__all__ = ["Queue", "SimpleQueue", "JoinableQueue"]
-
-_T = TypeVar("_T")
-
-class Queue(Generic[_T]):
-    # FIXME: `ctx` is a circular dependency and it's not actually optional.
-    # It's marked as such to be able to use the generic Queue in __init__.pyi.
-    def __init__(self, maxsize: int = 0, *, ctx: Any = ...) -> None: ...
-    def put(self, obj: _T, block: bool = True, timeout: float | None = None) -> None: ...
-    def get(self, block: bool = True, timeout: float | None = None) -> _T: ...
-    def qsize(self) -> int: ...
-    def empty(self) -> bool: ...
-    def full(self) -> bool: ...
-    def get_nowait(self) -> _T: ...
-    def put_nowait(self, obj: _T) -> None: ...
-    def close(self) -> None: ...
-    def join_thread(self) -> None: ...
-    def cancel_join_thread(self) -> None: ...
-    if sys.version_info >= (3, 12):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
-            """
-            Represent a PEP 585 generic type
-
-            E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
-            """
-            ...
-
-class JoinableQueue(Queue[_T]):
-    def task_done(self) -> None: ...
-    def join(self) -> None: ...
-
-class SimpleQueue(Generic[_T]):
-    def __init__(self, *, ctx: Any = ...) -> None: ...
-    if sys.version_info >= (3, 9):
-        def close(self) -> None: ...
-
-    def empty(self) -> bool: ...
-    def get(self) -> _T: ...
-    def put(self, obj: _T) -> None: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
-            """
-            Represent a PEP 585 generic type
-
-            E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
-            """
-            ...
+import sys
+from typing import Any, Generic, TypeVar
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+__all__ = ["Queue", "SimpleQueue", "JoinableQueue"]
+
+_T = TypeVar("_T")
+
+class Queue(Generic[_T]):
+    # FIXME: `ctx` is a circular dependency and it's not actually optional.
+    # It's marked as such to be able to use the generic Queue in __init__.pyi.
+    def __init__(self, maxsize: int = 0, *, ctx: Any = ...) -> None: ...
+    def put(self, obj: _T, block: bool = True, timeout: float | None = None) -> None: ...
+    def get(self, block: bool = True, timeout: float | None = None) -> _T: ...
+    def qsize(self) -> int: ...
+    def empty(self) -> bool: ...
+    def full(self) -> bool: ...
+    def get_nowait(self) -> _T: ...
+    def put_nowait(self, obj: _T) -> None: ...
+    def close(self) -> None: ...
+    def join_thread(self) -> None: ...
+    def cancel_join_thread(self) -> None: ...
+    if sys.version_info >= (3, 12):
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+            """
+            Represent a PEP 585 generic type
+
+            E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
+            """
+            ...
+
+class JoinableQueue(Queue[_T]):
+    def task_done(self) -> None: ...
+    def join(self) -> None: ...
+
+class SimpleQueue(Generic[_T]):
+    def __init__(self, *, ctx: Any = ...) -> None: ...
+    if sys.version_info >= (3, 9):
+        def close(self) -> None: ...
+
+    def empty(self) -> bool: ...
+    def get(self) -> _T: ...
+    def put(self, obj: _T) -> None: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+            """
+            Represent a PEP 585 generic type
+
+            E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
+            """
+            ...

package/dist/typeshed-fallback/stdlib/multiprocessing/reduction.pyi

@@ -1,87 +1,87 @@
-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, Final
-
-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: Final[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[DupHandle, Any], handle: int, destination_pid: int) -> None: ...
-    def recv_handle(conn: connection.PipeConnection[Any, DupHandle]) -> int: ...
-
-    class DupHandle:
-        def __init__(self, handle: int, access: int, pid: int | None = None) -> None: ...
-        def detach(self) -> int: ...
-
-else:
-    ACKNOWLEDGE: Final[bool]
-
-    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: ...
+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, Final
+
+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: Final[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[DupHandle, Any], handle: int, destination_pid: int) -> None: ...
+    def recv_handle(conn: connection.PipeConnection[Any, DupHandle]) -> int: ...
+
+    class DupHandle:
+        def __init__(self, handle: int, access: int, pid: int | None = None) -> None: ...
+        def detach(self) -> int: ...
+
+else:
+    ACKNOWLEDGE: Final[bool]
+
+    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: ...

package/dist/typeshed-fallback/stdlib/multiprocessing/resource_sharer.pyi

@@ -1,20 +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: ...
+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: ...