layermap 0.1.0

package/analyzers/project-map-python/typeshed/stdlib/multiprocessing/managers.pyi

@@ -0,0 +1,389 @@
+import queue
+import sys
+import threading
+from _typeshed import SupportsKeysAndGetItem, SupportsRichComparison, SupportsRichComparisonT
+from collections.abc import (
+    Callable,
+    Iterable,
+    Iterator,
+    Mapping,
+    MutableMapping,
+    MutableSequence,
+    MutableSet,
+    Sequence,
+    Set as AbstractSet,
+)
+from types import GenericAlias, TracebackType
+from typing import Any, AnyStr, ClassVar, Generic, SupportsIndex, TypeAlias, TypeVar, overload
+from typing_extensions import Self
+
+from . import pool
+from .connection import Connection, _Address
+from .context import BaseContext
+from .shared_memory import _SLT, ShareableList as _ShareableList, SharedMemory as _SharedMemory
+from .util import Finalize as _Finalize
+
+__all__ = ["BaseManager", "SyncManager", "BaseProxy", "Token", "SharedMemoryManager"]
+
+_T = TypeVar("_T")
+_T1 = TypeVar("_T1")
+_T2 = TypeVar("_T2")
+_KT = TypeVar("_KT")
+_VT = TypeVar("_VT")
+_S = TypeVar("_S")
+
+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:
+    __slots__ = ("typeid", "address", "id")
+    typeid: str | bytes | None
+    address: _Address | None
+    id: str | bytes | int | None
+    def __init__(self, typeid: bytes | str | None, address: _Address | None, 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[_Address, 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
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+if sys.version_info >= (3, 13):
+    class _BaseDictProxy(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]
+        if sys.version_info >= (3, 14):
+            # Next methods are copied from builtins.dict
+            @overload
+            def fromkeys(self, iterable: Iterable[_T], value: None = None, /) -> dict[_T, Any | None]: ...
+            @overload
+            def fromkeys(self, iterable: Iterable[_T], value: _S, /) -> dict[_T, _S]: ...
+
+            def __reversed__(self) -> Iterator[_KT]: ...
+
+            @overload
+            def __or__(self, value: dict[_KT, _VT], /) -> dict[_KT, _VT]: ...
+            @overload
+            def __or__(self, value: dict[_T1, _T2], /) -> dict[_KT | _T1, _VT | _T2]: ...
+
+            @overload
+            def __ror__(self, value: dict[_KT, _VT], /) -> dict[_KT, _VT]: ...
+            @overload
+            def __ror__(self, value: dict[_T1, _T2], /) -> dict[_KT | _T1, _VT | _T2]: ...
+
+            @overload  # type: ignore[misc]
+            def __ior__(self, value: SupportsKeysAndGetItem[_KT, _VT], /) -> Self: ...
+            @overload
+            def __ior__(self, value: Iterable[tuple[_KT, _VT]], /) -> Self: ...
+
+    class DictProxy(_BaseDictProxy[_KT, _VT]):
+        def __class_getitem__(cls, args: Any, /) -> GenericAlias: ...
+
+else:
+    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]
+
+if sys.version_info >= (3, 14):
+    class _BaseSetProxy(BaseProxy, MutableSet[_T]):
+        __builtins__: ClassVar[dict[str, Any]]
+        # Copied from builtins.set
+        def add(self, element: _T, /) -> None: ...
+        def copy(self) -> set[_T]: ...
+        def clear(self) -> None: ...
+        def difference(self, *s: Iterable[Any]) -> set[_T]: ...
+        def difference_update(self, *s: Iterable[Any]) -> None: ...
+        def discard(self, element: _T, /) -> None: ...
+        def intersection(self, *s: Iterable[Any]) -> set[_T]: ...
+        def intersection_update(self, *s: Iterable[Any]) -> None: ...
+        def isdisjoint(self, s: Iterable[Any], /) -> bool: ...
+        def issubset(self, s: Iterable[Any], /) -> bool: ...
+        def issuperset(self, s: Iterable[Any], /) -> bool: ...
+        def pop(self) -> _T: ...
+        def remove(self, element: _T, /) -> None: ...
+        def symmetric_difference(self, s: Iterable[_T], /) -> set[_T]: ...
+        def symmetric_difference_update(self, s: Iterable[_T], /) -> None: ...
+        def union(self, *s: Iterable[_S]) -> set[_T | _S]: ...
+        def update(self, *s: Iterable[_T]) -> None: ...
+        def __len__(self) -> int: ...
+        def __contains__(self, o: object, /) -> bool: ...
+        def __iter__(self) -> Iterator[_T]: ...
+        def __and__(self, value: AbstractSet[object], /) -> set[_T]: ...
+        def __iand__(self, value: AbstractSet[object], /) -> Self: ...
+        def __or__(self, value: AbstractSet[_S], /) -> set[_T | _S]: ...
+        def __ior__(self, value: AbstractSet[_T], /) -> Self: ...  # type: ignore[override,misc]
+        def __sub__(self, value: AbstractSet[_T | None], /) -> set[_T]: ...
+        def __isub__(self, value: AbstractSet[object], /) -> Self: ...
+        def __xor__(self, value: AbstractSet[_S], /) -> set[_T | _S]: ...
+        def __ixor__(self, value: AbstractSet[_T], /) -> Self: ...  # type: ignore[override,misc]
+        def __le__(self, value: AbstractSet[object], /) -> bool: ...
+        def __lt__(self, value: AbstractSet[object], /) -> bool: ...
+        def __ge__(self, value: AbstractSet[object], /) -> bool: ...
+        def __gt__(self, value: AbstractSet[object], /) -> bool: ...
+        def __eq__(self, value: object, /) -> bool: ...
+        def __rand__(self, value: AbstractSet[object], /) -> set[_T]: ...
+        def __ror__(self, value: AbstractSet[_S], /) -> set[_T | _S]: ...  # type: ignore[misc]
+        def __rsub__(self, value: AbstractSet[_T], /) -> set[_T]: ...
+        def __rxor__(self, value: AbstractSet[_S], /) -> set[_T | _S]: ...  # type: ignore[misc]
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+    class SetProxy(_BaseSetProxy[_T]): ...
+
+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[SupportsIndex | None], /) -> None: ...
+
+    @overload
+    def __getitem__(self, i: SupportsIndex, /) -> _T: ...
+    @overload
+    def __getitem__(self, s: slice[SupportsIndex | None], /) -> list[_T]: ...
+
+    @overload
+    def __setitem__(self, i: SupportsIndex, o: _T, /) -> None: ...
+    @overload
+    def __setitem__(self, s: slice[SupportsIndex | None], o: Iterable[_T], /) -> None: ...
+
+    def __mul__(self, n: SupportsIndex, /) -> list[_T]: ...
+    def __rmul__(self, n: SupportsIndex, /) -> list[_T]: ...
+    def __imul__(self, value: SupportsIndex, /) -> Self: ...
+    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: ...
+    if sys.version_info >= (3, 14):
+        # Next methods are copied from builtins.list
+        def clear(self) -> None: ...
+        def copy(self) -> list[_T]: ...
+
+    # 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]
+    if sys.version_info >= (3, 13):
+        def __class_getitem__(cls, args: Any, /) -> Any: ...
+
+# Send is (kind, result)
+# Receive is (id, methodname, args, kwds)
+_ServerConnection: TypeAlias = Connection[tuple[str, Any], tuple[str, str, Iterable[Any], Mapping[str, Any]]]
+
+# Returned by BaseManager.get_server()
+class Server:
+    address: _Address | None
+    id_to_obj: dict[str, tuple[Any, set[str], dict[str, str]]]
+    fallback_mapping: dict[str, Callable[[_ServerConnection, str, Any], Any]]
+    public: list[str]
+    # Registry values are (callable, exposed, method_to_typeid, proxytype)
+    def __init__(
+        self,
+        registry: dict[str, tuple[Callable[..., Any], Iterable[str], dict[str, str], Any]],
+        address: _Address | None,
+        authkey: bytes,
+        serializer: str,
+    ) -> None: ...
+    def serve_forever(self) -> None: ...
+    def accepter(self) -> None: ...
+    def handle_request(self, conn: _ServerConnection) -> None: ...
+    def serve_client(self, conn: _ServerConnection) -> None: ...
+    def fallback_getvalue(self, conn: _ServerConnection, ident: str, obj: _T) -> _T: ...
+    def fallback_str(self, conn: _ServerConnection, ident: str, obj: Any) -> str: ...
+    def fallback_repr(self, conn: _ServerConnection, ident: str, obj: Any) -> str: ...
+    def dummy(self, c: _ServerConnection) -> None: ...
+    def debug_info(self, c: _ServerConnection) -> str: ...
+    def number_of_objects(self, c: _ServerConnection) -> int: ...
+    def shutdown(self, c: _ServerConnection) -> None: ...
+    def create(self, c: _ServerConnection, typeid: str, /, *args: Any, **kwds: Any) -> tuple[str, tuple[str, ...]]: ...
+    def get_methods(self, c: _ServerConnection, token: Token) -> set[str]: ...
+    def accept_connection(self, c: _ServerConnection, name: str) -> None: ...
+    def incref(self, c: _ServerConnection, ident: str) -> None: ...
+    def decref(self, c: _ServerConnection, ident: str) -> None: ...
+
+class BaseManager:
+    if sys.version_info >= (3, 11):
+        def __init__(
+            self,
+            address: _Address | None = None,
+            authkey: bytes | None = None,
+            serializer: str = "pickle",
+            ctx: BaseContext | None = None,
+            *,
+            shutdown_timeout: float = 1.0,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            address: _Address | 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: ...
+    shutdown: _Finalize  # only available after start() was called
+    def join(self, timeout: float | None = None) -> None: ...  # undocumented
+    @property
+    def address(self) -> _Address | None: ...
+    @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 Barrier(
+        self, parties: int, action: Callable[[], None] | None = None, timeout: float | None = None
+    ) -> threading.Barrier: ...
+    def BoundedSemaphore(self, value: int = 1) -> threading.BoundedSemaphore: ...
+    def Condition(self, lock: threading.Lock | threading._RLock | None = None) -> threading.Condition: ...
+    def Event(self) -> threading.Event: ...
+    def Lock(self) -> threading.Lock: ...
+    def Namespace(self) -> _Namespace: ...
+    def Pool(
+        self,
+        processes: int | None = None,
+        initializer: Callable[..., object] | None = None,
+        initargs: Iterable[Any] = (),
+        maxtasksperchild: int | None = None,
+        context: Any | None = None,
+    ) -> pool.Pool: ...
+    def Queue(self, maxsize: int = ...) -> queue.Queue[Any]: ...
+    def JoinableQueue(self, maxsize: int = ...) -> queue.Queue[Any]: ...
+    def RLock(self) -> threading.RLock: ...
+    def Semaphore(self, value: int = 1) -> 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]: ...
+
+    # Overloads are copied from builtins.list.__init__
+    @overload
+    def list(self, iterable: Iterable[_T], /) -> ListProxy[_T]: ...
+    @overload
+    def list(self) -> ListProxy[Any]: ...
+
+    if sys.version_info >= (3, 14):
+        @overload
+        def set(self, iterable: Iterable[_T], /) -> SetProxy[_T]: ...
+        @overload
+        def set(self) -> SetProxy[Any]: ...
+
+class RemoteError(Exception): ...
+
+class SharedMemoryServer(Server):
+    def track_segment(self, c: _ServerConnection, segment_name: str) -> None: ...
+    def release_segment(self, c: _ServerConnection, segment_name: str) -> None: ...
+    def list_segments(self, c: _ServerConnection) -> list[str]: ...
+
+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: ...

package/analyzers/project-map-python/typeshed/stdlib/multiprocessing/pool.pyi

@@ -0,0 +1,101 @@
+from collections.abc import Callable, Iterable, Mapping
+from multiprocessing.context import DefaultContext, Process
+from types import GenericAlias, TracebackType
+from typing import Any, Final, Generic, TypeVar
+from typing_extensions import Self
+
+__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: ...
+    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(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: ...
+    @staticmethod
+    def Process(ctx: DefaultContext, *args: Any, **kwds: Any) -> Process: ...
+    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/analyzers/project-map-python/typeshed/stdlib/multiprocessing/popen_fork.pyi

@@ -0,0 +1,26 @@
+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: ...
+        if sys.version_info >= (3, 14):
+            def interrupt(self) -> None: ...
+
+        def terminate(self) -> None: ...
+        def kill(self) -> None: ...
+        def close(self) -> None: ...

package/analyzers/project-map-python/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

package/analyzers/project-map-python/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

package/analyzers/project-map-python/typeshed/stdlib/multiprocessing/popen_spawn_win32.pyi

@@ -0,0 +1,30 @@
+import sys
+from multiprocessing.process import BaseProcess
+from typing import ClassVar, Final
+
+from .util import Finalize
+
+if sys.platform == "win32":
+    __all__ = ["Popen"]
+
+    TERMINATE: Final[int]
+    WINEXE: Final[bool]
+    WINSERVICE: Final[bool]
+    WINENV: Final[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: ...

package/analyzers/project-map-python/typeshed/stdlib/multiprocessing/process.pyi

@@ -0,0 +1,43 @@
+import sys
+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: ...
+    if sys.version_info >= (3, 14):
+        def interrupt(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: ...

package/analyzers/project-map-python/typeshed/stdlib/multiprocessing/queues.pyi

@@ -0,0 +1,46 @@
+import sys
+from types import GenericAlias
+from typing import Any, Generic, NewType, TypeVar
+
+__all__ = ["Queue", "SimpleQueue", "JoinableQueue"]
+
+_T = TypeVar("_T")
+
+_QueueState = NewType("_QueueState", object)
+_JoinableQueueState = NewType("_JoinableQueueState", object)
+_SimpleQueueState = NewType("_SimpleQueueState", object)
+
+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 __getstate__(self) -> _QueueState: ...
+    def __setstate__(self, state: _QueueState) -> 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 __getstate__(self) -> _JoinableQueueState: ...  # type: ignore[override]
+    def __setstate__(self, state: _JoinableQueueState) -> None: ...  # type: ignore[override]
+    def task_done(self) -> None: ...
+    def join(self) -> None: ...
+
+class SimpleQueue(Generic[_T]):
+    def __init__(self, *, ctx: Any = ...) -> None: ...
+    def close(self) -> None: ...
+    def empty(self) -> bool: ...
+    def __getstate__(self) -> _SimpleQueueState: ...
+    def __setstate__(self, state: _SimpleQueueState) -> None: ...
+    def get(self) -> _T: ...
+    def put(self, obj: _T) -> None: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...