jaclang 0.6.1__py3-none-any.whl → 0.6.2__py3-none-any.whl

jaclang/vendor/mypy/typeshed/stdlib/multiprocessing/managers.pyi

@@ -0,0 +1,270 @@
+import queue
+import sys
+import threading
+from _typeshed import (
+    SupportsKeysAndGetItem,
+    SupportsRichComparison,
+    SupportsRichComparisonT,
+)
+from collections.abc import (
+    Callable,
+    Iterable,
+    Iterator,
+    Mapping,
+    MutableMapping,
+    MutableSequence,
+    Sequence,
+)
+from types import TracebackType
+from typing import Any, AnyStr, ClassVar, Generic, SupportsIndex, TypeVar, overload
+from typing_extensions import Self, TypeAlias
+
+from .connection import Connection
+from .context import BaseContext
+from .shared_memory import (
+    _SLT,
+    ShareableList as _ShareableList,
+    SharedMemory as _SharedMemory,
+)
+
+__all__ = ["BaseManager", "SyncManager", "BaseProxy", "Token", "SharedMemoryManager"]
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+_T = TypeVar("_T")
+_KT = TypeVar("_KT")
+_VT = TypeVar("_VT")
+
+class Namespace:
+    def __init__(self, **kwds: Any) -> None: ...
+    def __getattr__(self, __name: str) -> Any: ...
+    def __setattr__(self, __name: str, __value: Any) -> None: ...
+
+_Namespace: TypeAlias = Namespace
+
+class Token:
+    typeid: str | bytes | None
+    address: tuple[str | bytes, int]
+    id: str | bytes | int | None
+    def __init__(
+        self,
+        typeid: bytes | str | None,
+        address: tuple[str | bytes, int],
+        id: str | bytes | int | None,
+    ) -> None: ...
+    def __getstate__(
+        self,
+    ) -> tuple[
+        str | bytes | None, tuple[str | bytes, int], str | bytes | int | None
+    ]: ...
+    def __setstate__(
+        self,
+        state: tuple[
+            str | bytes | None, tuple[str | bytes, int], str | bytes | int | None
+        ],
+    ) -> None: ...
+
+class BaseProxy:
+    _address_to_local: dict[Any, Any]
+    _mutex: Any
+    def __init__(
+        self,
+        token: Any,
+        serializer: str,
+        manager: Any = None,
+        authkey: AnyStr | None = None,
+        exposed: Any = None,
+        incref: bool = True,
+        manager_owned: bool = False,
+    ) -> None: ...
+    def __deepcopy__(self, memo: Any | None) -> Any: ...
+    def _callmethod(
+        self, methodname: str, args: tuple[Any, ...] = (), kwds: dict[Any, Any] = {}
+    ) -> None: ...
+    def _getvalue(self) -> Any: ...
+    def __reduce__(self) -> tuple[Any, tuple[Any, Any, str, dict[Any, Any]]]: ...
+
+class ValueProxy(BaseProxy, Generic[_T]):
+    def get(self) -> _T: ...
+    def set(self, value: _T) -> None: ...
+    value: _T
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+class DictProxy(BaseProxy, MutableMapping[_KT, _VT]):
+    __builtins__: ClassVar[dict[str, Any]]
+    def __len__(self) -> int: ...
+    def __getitem__(self, __key: _KT) -> _VT: ...
+    def __setitem__(self, __key: _KT, __value: _VT) -> None: ...
+    def __delitem__(self, __key: _KT) -> None: ...
+    def __iter__(self) -> Iterator[_KT]: ...
+    def copy(self) -> dict[_KT, _VT]: ...
+    @overload  # type: ignore[override]
+    def get(self, __key: _KT) -> _VT | None: ...
+    @overload
+    def get(self, __key: _KT, __default: _VT) -> _VT: ...
+    @overload
+    def get(self, __key: _KT, __default: _T) -> _VT | _T: ...
+    @overload
+    def pop(self, __key: _KT) -> _VT: ...
+    @overload
+    def pop(self, __key: _KT, __default: _VT) -> _VT: ...
+    @overload
+    def pop(self, __key: _KT, __default: _T) -> _VT | _T: ...
+    def keys(self) -> list[_KT]: ...  # type: ignore[override]
+    def items(self) -> list[tuple[_KT, _VT]]: ...  # type: ignore[override]
+    def values(self) -> list[_VT]: ...  # type: ignore[override]
+
+class BaseListProxy(BaseProxy, MutableSequence[_T]):
+    __builtins__: ClassVar[dict[str, Any]]
+    def __len__(self) -> int: ...
+    def __add__(self, __x: list[_T]) -> list[_T]: ...
+    def __delitem__(self, __i: SupportsIndex | slice) -> None: ...
+    @overload
+    def __getitem__(self, __i: SupportsIndex) -> _T: ...
+    @overload
+    def __getitem__(self, __s: slice) -> list[_T]: ...
+    @overload
+    def __setitem__(self, __i: SupportsIndex, __o: _T) -> None: ...
+    @overload
+    def __setitem__(self, __s: slice, __o: Iterable[_T]) -> None: ...
+    def __mul__(self, __n: SupportsIndex) -> list[_T]: ...
+    def __rmul__(self, __n: SupportsIndex) -> list[_T]: ...
+    def __reversed__(self) -> Iterator[_T]: ...
+    def append(self, __object: _T) -> None: ...
+    def extend(self, __iterable: Iterable[_T]) -> None: ...
+    def pop(self, __index: SupportsIndex = ...) -> _T: ...
+    def index(
+        self, __value: _T, __start: SupportsIndex = ..., __stop: SupportsIndex = ...
+    ) -> int: ...
+    def count(self, __value: _T) -> int: ...
+    def insert(self, __index: SupportsIndex, __object: _T) -> None: ...
+    def remove(self, __value: _T) -> None: ...
+    # Use BaseListProxy[SupportsRichComparisonT] for the first overload rather than [SupportsRichComparison]
+    # to work around invariance
+    @overload
+    def sort(
+        self: BaseListProxy[SupportsRichComparisonT],
+        *,
+        key: None = None,
+        reverse: bool = ...,
+    ) -> None: ...
+    @overload
+    def sort(
+        self, *, key: Callable[[_T], SupportsRichComparison], reverse: bool = ...
+    ) -> None: ...
+
+class ListProxy(BaseListProxy[_T]):
+    def __iadd__(self, __value: Iterable[_T]) -> Self: ...  # type: ignore[override]
+    def __imul__(self, __value: SupportsIndex) -> Self: ...  # type: ignore[override]
+
+# Returned by BaseManager.get_server()
+class Server:
+    address: Any
+    def __init__(
+        self,
+        registry: dict[str, tuple[Callable[..., Any], Any, Any, Any]],
+        address: Any,
+        authkey: bytes,
+        serializer: str,
+    ) -> None: ...
+    def serve_forever(self) -> None: ...
+    def accept_connection(self, c: Connection, name: str) -> None: ...
+
+class BaseManager:
+    if sys.version_info >= (3, 11):
+        def __init__(
+            self,
+            address: Any | None = None,
+            authkey: bytes | None = None,
+            serializer: str = "pickle",
+            ctx: BaseContext | None = None,
+            *,
+            shutdown_timeout: float = 1.0,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            address: Any | None = None,
+            authkey: bytes | None = None,
+            serializer: str = "pickle",
+            ctx: BaseContext | None = None,
+        ) -> None: ...
+
+    def get_server(self) -> Server: ...
+    def connect(self) -> None: ...
+    def start(
+        self,
+        initializer: Callable[..., object] | None = None,
+        initargs: Iterable[Any] = (),
+    ) -> None: ...
+    def shutdown(self) -> None: ...  # only available after start() was called
+    def join(self, timeout: float | None = None) -> None: ...  # undocumented
+    @property
+    def address(self) -> Any: ...
+    @classmethod
+    def register(
+        cls,
+        typeid: str,
+        callable: Callable[..., object] | None = None,
+        proxytype: Any = None,
+        exposed: Sequence[str] | None = None,
+        method_to_typeid: Mapping[str, str] | None = None,
+        create_method: bool = True,
+    ) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None: ...
+
+class SyncManager(BaseManager):
+    def BoundedSemaphore(self, value: Any = ...) -> threading.BoundedSemaphore: ...
+    def Condition(self, lock: Any = ...) -> threading.Condition: ...
+    def Event(self) -> threading.Event: ...
+    def Lock(self) -> threading.Lock: ...
+    def Namespace(self) -> _Namespace: ...
+    def Queue(self, maxsize: int = ...) -> queue.Queue[Any]: ...
+    def RLock(self) -> threading.RLock: ...
+    def Semaphore(self, value: Any = ...) -> threading.Semaphore: ...
+    def Array(self, typecode: Any, sequence: Sequence[_T]) -> Sequence[_T]: ...
+    def Value(self, typecode: Any, value: _T) -> ValueProxy[_T]: ...
+    # Overloads are copied from builtins.dict.__init__
+    @overload
+    def dict(self) -> DictProxy[Any, Any]: ...
+    @overload
+    def dict(self, **kwargs: _VT) -> DictProxy[str, _VT]: ...
+    @overload
+    def dict(self, __map: SupportsKeysAndGetItem[_KT, _VT]) -> DictProxy[_KT, _VT]: ...
+    @overload
+    def dict(
+        self, __map: SupportsKeysAndGetItem[str, _VT], **kwargs: _VT
+    ) -> DictProxy[str, _VT]: ...
+    @overload
+    def dict(self, __iterable: Iterable[tuple[_KT, _VT]]) -> DictProxy[_KT, _VT]: ...
+    @overload
+    def dict(
+        self, __iterable: Iterable[tuple[str, _VT]], **kwargs: _VT
+    ) -> DictProxy[str, _VT]: ...
+    @overload
+    def dict(self, __iterable: Iterable[list[str]]) -> DictProxy[str, str]: ...
+    @overload
+    def dict(self, __iterable: Iterable[list[bytes]]) -> DictProxy[bytes, bytes]: ...
+    @overload
+    def list(self, __sequence: Sequence[_T]) -> ListProxy[_T]: ...
+    @overload
+    def list(self) -> ListProxy[Any]: ...
+
+class RemoteError(Exception): ...
+class SharedMemoryServer(Server): ...
+
+class SharedMemoryManager(BaseManager):
+    def get_server(self) -> SharedMemoryServer: ...
+    def SharedMemory(self, size: int) -> _SharedMemory: ...
+    def ShareableList(
+        self, sequence: Iterable[_SLT] | None
+    ) -> _ShareableList[_SLT]: ...
+    def __del__(self) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/multiprocessing/pool.pyi

@@ -0,0 +1,137 @@
+import sys
+from collections.abc import Callable, Iterable, Iterator, Mapping
+from types import TracebackType
+from typing import Any, Generic, Literal, 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: ...
+
+# 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(Iterator[_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: Literal["INIT"]
+RUN: Literal["RUN"]
+CLOSE: Literal["CLOSE"]
+TERMINATE: Literal["TERMINATE"]

jaclang/vendor/mypy/typeshed/stdlib/multiprocessing/popen_fork.pyi

@@ -0,0 +1,23 @@
+import sys
+from typing import ClassVar
+
+from .process import BaseProcess
+from .util import Finalize
+
+if sys.platform != "win32":
+    __all__ = ["Popen"]
+
+    class Popen:
+        finalizer: Finalize | None
+        method: ClassVar[str]
+        pid: int
+        returncode: int | None
+        sentinel: int  # doesn't exist if os.fork in _launch returns 0
+
+        def __init__(self, process_obj: BaseProcess) -> None: ...
+        def duplicate_for_child(self, fd: int) -> int: ...
+        def poll(self, flag: int = 1) -> int | None: ...
+        def wait(self, timeout: float | None = None) -> int | None: ...
+        def terminate(self) -> None: ...
+        def kill(self) -> None: ...
+        def close(self) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/multiprocessing/popen_forkserver.pyi

@@ -0,0 +1,16 @@
+import sys
+from typing import ClassVar
+
+from . import popen_fork
+from .util import Finalize
+
+if sys.platform != "win32":
+    __all__ = ["Popen"]
+
+    class _DupFd:
+        def __init__(self, ind: int) -> None: ...
+        def detach(self) -> int: ...
+
+    class Popen(popen_fork.Popen):
+        DupFd: ClassVar[type[_DupFd]]
+        finalizer: Finalize

jaclang/vendor/mypy/typeshed/stdlib/multiprocessing/popen_spawn_posix.pyi

@@ -0,0 +1,20 @@
+import sys
+from typing import ClassVar
+
+from . import popen_fork
+from .util import Finalize
+
+if sys.platform != "win32":
+    __all__ = ["Popen"]
+
+    class _DupFd:
+        fd: int
+
+        def __init__(self, fd: int) -> None: ...
+        def detach(self) -> int: ...
+
+    class Popen(popen_fork.Popen):
+        DupFd: ClassVar[type[_DupFd]]
+        finalizer: Finalize
+        pid: int  # may not exist if _launch raises in second try / except
+        sentinel: int  # may not exist if _launch raises in second try / except

jaclang/vendor/mypy/typeshed/stdlib/multiprocessing/popen_spawn_win32.pyi

@@ -0,0 +1,30 @@
+import sys
+from multiprocessing.process import BaseProcess
+from typing import ClassVar
+
+from .util import Finalize
+
+if sys.platform == "win32":
+    __all__ = ["Popen"]
+
+    TERMINATE: int
+    WINEXE: bool
+    WINSERVICE: bool
+    WINENV: bool
+
+    class Popen:
+        finalizer: Finalize
+        method: ClassVar[str]
+        pid: int
+        returncode: int | None
+        sentinel: int
+
+        def __init__(self, process_obj: BaseProcess) -> None: ...
+        def duplicate_for_child(self, handle: int) -> int: ...
+        def wait(self, timeout: float | None = None) -> int | None: ...
+        def poll(self) -> int | None: ...
+        def terminate(self) -> None: ...
+
+        kill = terminate
+
+        def close(self) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/multiprocessing/process.pyi

@@ -0,0 +1,39 @@
+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: ...
+    @property
+    def ident(self) -> int | None: ...
+    @property
+    def pid(self) -> int | None: ...
+    @property
+    def sentinel(self) -> int: ...
+
+def current_process() -> BaseProcess: ...
+def active_children() -> list[BaseProcess]: ...
+def parent_process() -> BaseProcess | None: ...

jaclang/vendor/mypy/typeshed/stdlib/multiprocessing/queues.pyi

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

jaclang/vendor/mypy/typeshed/stdlib/multiprocessing/reduction.pyi

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