layermap 0.1.0

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

@@ -0,0 +1,94 @@
+import socket
+import sys
+from _typeshed import Incomplete, ReadableBuffer
+from collections.abc import Iterable
+from types import TracebackType
+from typing import Any, Generic, SupportsIndex, TypeAlias, TypeVar
+from typing_extensions import Self
+
+__all__ = ["Client", "Listener", "Pipe", "wait"]
+
+# https://docs.python.org/3/library/multiprocessing.html#address-formats
+_Address: TypeAlias = str | tuple[str, int]
+
+# Defaulting to Any to avoid forcing generics on a lot of pre-existing code
+_SendT_contra = TypeVar("_SendT_contra", contravariant=True, default=Any)
+_RecvT_co = TypeVar("_RecvT_co", covariant=True, default=Any)
+
+class _ConnectionBase(Generic[_SendT_contra, _RecvT_co]):
+    def __init__(self, handle: SupportsIndex, readable: bool = True, writable: bool = True) -> None: ...
+    @property
+    def closed(self) -> bool: ...  # undocumented
+    @property
+    def readable(self) -> bool: ...  # undocumented
+    @property
+    def writable(self) -> bool: ...  # undocumented
+    def fileno(self) -> int: ...
+    def close(self) -> None: ...
+    def send_bytes(self, buf: ReadableBuffer, offset: int = 0, size: int | None = None) -> None: ...
+    def send(self, obj: _SendT_contra) -> None: ...
+    def recv_bytes(self, maxlength: int | None = None) -> bytes: ...
+    def recv_bytes_into(self, buf: Any, offset: int = 0) -> int: ...
+    def recv(self) -> _RecvT_co: ...
+    def poll(self, timeout: float | None = 0.0) -> bool: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, exc_tb: TracebackType | None
+    ) -> None: ...
+    def __del__(self) -> None: ...
+
+class Connection(_ConnectionBase[_SendT_contra, _RecvT_co]): ...
+
+if sys.platform == "win32":
+    class PipeConnection(_ConnectionBase[_SendT_contra, _RecvT_co]): ...
+
+class Listener:
+    def __init__(
+        self, address: _Address | None = None, family: str | None = None, backlog: int = 1, authkey: bytes | None = None
+    ) -> None: ...
+    if sys.platform != "win32":
+        def accept(self) -> Connection[Incomplete, Incomplete]: ...
+    else:
+        def accept(self) -> Connection[Incomplete, Incomplete] | PipeConnection[Incomplete, Incomplete]: ...
+
+    def close(self) -> None: ...
+    @property
+    def address(self) -> _Address: ...
+    @property
+    def last_accepted(self) -> _Address | None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, exc_tb: TracebackType | None
+    ) -> None: ...
+
+# Any: send and recv methods unused
+if sys.version_info >= (3, 12):
+    def deliver_challenge(connection: _ConnectionBase[Any, Any], authkey: bytes, digest_name: str = "sha256") -> None: ...
+
+else:
+    def deliver_challenge(connection: _ConnectionBase[Any, Any], authkey: bytes) -> None: ...
+
+def answer_challenge(connection: _ConnectionBase[Any, Any], authkey: bytes) -> None: ...
+def wait(
+    object_list: Iterable[_ConnectionBase[_SendT_contra, _RecvT_co] | socket.socket | int], timeout: float | None = None
+) -> list[_ConnectionBase[_SendT_contra, _RecvT_co] | socket.socket | int]: ...
+
+if sys.platform != "win32":
+    def Client(address: _Address, family: str | None = None, authkey: bytes | None = None) -> Connection[Any, Any]: ...
+
+else:
+    def Client(
+        address: _Address, family: str | None = None, authkey: bytes | None = None
+    ) -> Connection[Any, Any] | PipeConnection[Any, Any]: ...
+
+# N.B. Keep this in sync with multiprocessing.context.BaseContext.Pipe.
+# _ConnectionBase is the common base class of Connection and PipeConnection
+# and can be used in cross-platform code.
+#
+# The two connections should have the same generic types but inverted (Connection[_T1, _T2], Connection[_T2, _T1]).
+# However, TypeVars scoped entirely within a return annotation is unspecified in the spec.
+if sys.platform != "win32":
+    def Pipe(duplex: bool = True) -> tuple[Connection[Any, Any], Connection[Any, Any]]: ...
+
+else:
+    def Pipe(duplex: bool = True) -> tuple[PipeConnection[Any, Any], PipeConnection[Any, Any]]: ...

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

@@ -0,0 +1,220 @@
+import ctypes
+import sys
+from _ctypes import _CData
+from collections.abc import Callable, Iterable, Sequence
+from ctypes import _SimpleCData, c_char
+from logging import Logger, _Level as _LoggingLevel
+from multiprocessing import popen_fork, popen_forkserver, popen_spawn_posix, popen_spawn_win32, queues, synchronize
+from multiprocessing.managers import SyncManager
+from multiprocessing.pool import Pool as _Pool
+from multiprocessing.process import BaseProcess
+from multiprocessing.sharedctypes import Synchronized, SynchronizedArray, SynchronizedString
+from typing import Any, ClassVar, Literal, TypeAlias, TypeVar, overload
+
+if sys.platform != "win32":
+    from multiprocessing.connection import Connection
+else:
+    from multiprocessing.connection import PipeConnection
+
+__all__ = ()
+
+_LockLike: TypeAlias = synchronize.Lock | synchronize.RLock
+_T = TypeVar("_T")
+_CT = TypeVar("_CT", bound=_CData)
+
+class ProcessError(Exception): ...
+class BufferTooShort(ProcessError): ...
+class TimeoutError(ProcessError): ...
+class AuthenticationError(ProcessError): ...
+
+class BaseContext:
+    ProcessError: ClassVar[type[ProcessError]]
+    BufferTooShort: ClassVar[type[BufferTooShort]]
+    TimeoutError: ClassVar[type[TimeoutError]]
+    AuthenticationError: ClassVar[type[AuthenticationError]]
+
+    # N.B. The methods below are applied at runtime to generate
+    # multiprocessing.*, so the signatures should be identical (modulo self).
+    @staticmethod
+    def current_process() -> BaseProcess: ...
+    @staticmethod
+    def parent_process() -> BaseProcess | None: ...
+    @staticmethod
+    def active_children() -> list[BaseProcess]: ...
+    def cpu_count(self) -> int: ...
+    def Manager(self) -> SyncManager: ...
+
+    # N.B. Keep this in sync with multiprocessing.connection.Pipe.
+    # _ConnectionBase is the common base class of Connection and PipeConnection
+    # and can be used in cross-platform code.
+    #
+    # The two connections should have the same generic types but inverted (Connection[_T1, _T2], Connection[_T2, _T1]).
+    # However, TypeVars scoped entirely within a return annotation is unspecified in the spec.
+    if sys.platform != "win32":
+        def Pipe(self, duplex: bool = True) -> tuple[Connection[Any, Any], Connection[Any, Any]]: ...
+    else:
+        def Pipe(self, duplex: bool = True) -> tuple[PipeConnection[Any, Any], PipeConnection[Any, Any]]: ...
+
+    def Barrier(
+        self, parties: int, action: Callable[..., object] | None = None, timeout: float | None = None
+    ) -> synchronize.Barrier: ...
+    def BoundedSemaphore(self, value: int = 1) -> synchronize.BoundedSemaphore: ...
+    def Condition(self, lock: _LockLike | None = None) -> synchronize.Condition: ...
+    def Event(self) -> synchronize.Event: ...
+    def Lock(self) -> synchronize.Lock: ...
+    def RLock(self) -> synchronize.RLock: ...
+    def Semaphore(self, value: int = 1) -> synchronize.Semaphore: ...
+    def Queue(self, maxsize: int = 0) -> queues.Queue[Any]: ...
+    def JoinableQueue(self, maxsize: int = 0) -> queues.JoinableQueue[Any]: ...
+    def SimpleQueue(self) -> queues.SimpleQueue[Any]: ...
+    def Pool(
+        self,
+        processes: int | None = None,
+        initializer: Callable[..., object] | None = None,
+        initargs: Iterable[Any] = (),
+        maxtasksperchild: int | None = None,
+    ) -> _Pool: ...
+
+    @overload
+    def RawValue(self, typecode_or_type: type[_CT], *args: Any) -> _CT: ...
+    @overload
+    def RawValue(self, typecode_or_type: str, *args: Any) -> Any: ...
+
+    @overload
+    def RawArray(self, typecode_or_type: type[_CT], size_or_initializer: int | Sequence[Any]) -> ctypes.Array[_CT]: ...
+    @overload
+    def RawArray(self, typecode_or_type: str, size_or_initializer: int | Sequence[Any]) -> Any: ...
+
+    @overload
+    def Value(
+        self, typecode_or_type: type[_SimpleCData[_T]], *args: Any, lock: Literal[True] | _LockLike = True
+    ) -> Synchronized[_T]: ...
+    @overload
+    def Value(self, typecode_or_type: type[_CT], *args: Any, lock: Literal[False]) -> Synchronized[_CT]: ...
+    @overload
+    def Value(self, typecode_or_type: type[_CT], *args: Any, lock: Literal[True] | _LockLike = True) -> Synchronized[_CT]: ...
+    @overload
+    def Value(self, typecode_or_type: str, *args: Any, lock: Literal[True] | _LockLike = True) -> Synchronized[Any]: ...
+    @overload
+    def Value(self, typecode_or_type: str | type[_CData], *args: Any, lock: bool | _LockLike = True) -> Any: ...
+
+    @overload
+    def Array(
+        self, typecode_or_type: type[_SimpleCData[_T]], size_or_initializer: int | Sequence[Any], *, lock: Literal[False]
+    ) -> SynchronizedArray[_T]: ...
+    @overload
+    def Array(
+        self, typecode_or_type: type[c_char], size_or_initializer: int | Sequence[Any], *, lock: Literal[True] | _LockLike = True
+    ) -> SynchronizedString: ...
+    @overload
+    def Array(
+        self,
+        typecode_or_type: type[_SimpleCData[_T]],
+        size_or_initializer: int | Sequence[Any],
+        *,
+        lock: Literal[True] | _LockLike = True,
+    ) -> SynchronizedArray[_T]: ...
+    @overload
+    def Array(
+        self, typecode_or_type: str, size_or_initializer: int | Sequence[Any], *, lock: Literal[True] | _LockLike = True
+    ) -> SynchronizedArray[Any]: ...
+    @overload
+    def Array(
+        self, typecode_or_type: str | type[_CData], size_or_initializer: int | Sequence[Any], *, lock: bool | _LockLike = True
+    ) -> Any: ...
+
+    def freeze_support(self) -> None: ...
+    def get_logger(self) -> Logger: ...
+    def log_to_stderr(self, level: _LoggingLevel | None = None) -> Logger: ...
+    def allow_connection_pickling(self) -> None: ...
+    def set_executable(self, executable: str) -> None: ...
+    if sys.version_info >= (3, 15):
+        def set_forkserver_preload(
+            self, module_names: list[str], *, on_error: Literal["ignore", "warn", "fail"] = "ignore"
+        ) -> None: ...
+    else:
+        def set_forkserver_preload(self, module_names: list[str]) -> None: ...
+
+    @overload
+    def get_context(self, method: None = None) -> DefaultContext: ...
+    @overload
+    def get_context(self, method: Literal["spawn"]) -> SpawnContext: ...
+    if sys.platform != "win32":
+        @overload
+        def get_context(self, method: Literal["fork"]) -> ForkContext: ...
+        @overload
+        def get_context(self, method: Literal["forkserver"]) -> ForkServerContext: ...
+
+    @overload
+    def get_context(self, method: str) -> BaseContext: ...
+
+    @overload
+    def get_start_method(self, allow_none: Literal[False] = False) -> str: ...
+    @overload
+    def get_start_method(self, allow_none: bool) -> str | None: ...
+
+    def set_start_method(self, method: str | None, force: bool = False) -> None: ...
+
+    @property
+    def reducer(self) -> str: ...
+    @reducer.setter
+    def reducer(self, reduction: str) -> None: ...
+
+    def _check_available(self) -> None: ...
+
+class Process(BaseProcess):
+    _start_method: str | None
+    @staticmethod
+    def _Popen(process_obj: BaseProcess) -> DefaultContext: ...
+
+class DefaultContext(BaseContext):
+    Process: ClassVar[type[Process]]
+    def __init__(self, context: BaseContext) -> None: ...
+    def get_start_method(self, allow_none: bool = False) -> str: ...
+    def get_all_start_methods(self) -> list[str]: ...
+
+_default_context: DefaultContext
+
+class SpawnProcess(BaseProcess):
+    _start_method: str
+    if sys.platform != "win32":
+        @staticmethod
+        def _Popen(process_obj: BaseProcess) -> popen_spawn_posix.Popen: ...
+    else:
+        @staticmethod
+        def _Popen(process_obj: BaseProcess) -> popen_spawn_win32.Popen: ...
+
+class SpawnContext(BaseContext):
+    _name: str
+    Process: ClassVar[type[SpawnProcess]]
+
+if sys.platform != "win32":
+    class ForkProcess(BaseProcess):
+        _start_method: str
+        @staticmethod
+        def _Popen(process_obj: BaseProcess) -> popen_fork.Popen: ...
+
+    class ForkServerProcess(BaseProcess):
+        _start_method: str
+        @staticmethod
+        def _Popen(process_obj: BaseProcess) -> popen_forkserver.Popen: ...
+
+    class ForkContext(BaseContext):
+        _name: str
+        Process: ClassVar[type[ForkProcess]]
+
+    class ForkServerContext(BaseContext):
+        _name: str
+        Process: ClassVar[type[ForkServerProcess]]
+
+def _force_start_method(method: str) -> None: ...
+
+if sys.platform != "win32":
+    def get_spawning_popen() -> popen_forkserver.Popen | popen_spawn_posix.Popen | None: ...
+    def set_spawning_popen(popen: popen_forkserver.Popen | popen_spawn_posix.Popen | None) -> None: ...
+
+else:
+    def get_spawning_popen() -> popen_spawn_win32.Popen | None: ...
+    def set_spawning_popen(popen: popen_spawn_win32.Popen | None) -> None: ...
+
+def assert_spawning(obj: Any) -> None: ...

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

@@ -0,0 +1,89 @@
+import array
+import sys
+import threading
+import weakref
+from collections.abc import Callable, Iterable, Mapping, Sequence
+from queue import Queue as Queue
+from threading import (
+    Barrier as Barrier,
+    BoundedSemaphore as BoundedSemaphore,
+    Condition as Condition,
+    Event as Event,
+    Lock as Lock,
+    RLock as RLock,
+    Semaphore as Semaphore,
+)
+from typing import Any, Literal
+
+from .connection import Pipe as Pipe
+
+__all__ = [
+    "Process",
+    "current_process",
+    "active_children",
+    "freeze_support",
+    "Lock",
+    "RLock",
+    "Semaphore",
+    "BoundedSemaphore",
+    "Condition",
+    "Event",
+    "Barrier",
+    "Queue",
+    "Manager",
+    "Pipe",
+    "Pool",
+    "JoinableQueue",
+]
+
+JoinableQueue = Queue
+
+class DummyProcess(threading.Thread):
+    _children: weakref.WeakKeyDictionary[Any, Any]
+    _parent: threading.Thread
+    _pid: None
+    _start_called: int
+    @property
+    def exitcode(self) -> Literal[0] | None: ...
+    if sys.version_info >= (3, 14):
+        # Default changed in Python 3.14.1
+        def __init__(
+            self,
+            group: Any = None,
+            target: Callable[..., object] | None = None,
+            name: str | None = None,
+            args: Iterable[Any] = (),
+            kwargs: Mapping[str, Any] | None = None,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            group: Any = None,
+            target: Callable[..., object] | None = None,
+            name: str | None = None,
+            args: Iterable[Any] = (),
+            kwargs: Mapping[str, Any] | None = {},
+        ) -> None: ...
+
+Process = DummyProcess
+
+class Namespace:
+    def __init__(self, **kwds: Any) -> None: ...
+    def __getattr__(self, name: str, /) -> Any: ...
+    def __setattr__(self, name: str, value: Any, /) -> None: ...
+
+class Value:
+    _typecode: Any
+    _value: Any
+    value: Any
+    def __init__(self, typecode: Any, value: Any, lock: Any = True) -> None: ...
+
+def Array(typecode: Any, sequence: Sequence[Any], lock: Any = True) -> array.array[Any]: ...
+def Manager() -> Any: ...
+def Pool(processes: int | None = None, initializer: Callable[..., object] | None = None, initargs: Iterable[Any] = ()) -> Any: ...
+def active_children() -> list[Any]: ...
+
+current_process = threading.current_thread
+
+def freeze_support() -> None: ...
+def shutdown() -> None: ...

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

@@ -0,0 +1,39 @@
+from multiprocessing.connection import _Address
+from queue import Queue
+from types import TracebackType
+from typing import Any
+from typing_extensions import Self
+
+__all__ = ["Client", "Listener", "Pipe"]
+
+families: list[None]
+
+class Connection:
+    _in: Any
+    _out: Any
+    recv: Any
+    recv_bytes: Any
+    send: Any
+    send_bytes: Any
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, exc_tb: TracebackType | None
+    ) -> None: ...
+    def __init__(self, _in: Any, _out: Any) -> None: ...
+    def close(self) -> None: ...
+    def poll(self, timeout: float = 0.0) -> bool: ...
+
+class Listener:
+    _backlog_queue: Queue[Any] | None
+    @property
+    def address(self) -> Queue[Any] | None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, exc_tb: TracebackType | None
+    ) -> None: ...
+    def __init__(self, address: _Address | None = None, family: int | None = None, backlog: int = 1) -> None: ...
+    def accept(self) -> Connection: ...
+    def close(self) -> None: ...
+
+def Client(address: _Address) -> Connection: ...
+def Pipe(duplex: bool = True) -> tuple[Connection, Connection]: ...

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

@@ -0,0 +1,78 @@
+import sys
+from _typeshed import FileDescriptorLike, Unused
+from collections.abc import Sequence
+from struct import Struct
+from typing import Any, Final, Literal
+
+__all__ = ["ensure_running", "get_inherited_fds", "connect_to_new_process", "set_forkserver_preload"]
+
+MAXFDS_TO_SEND: Final = 256
+SIGNED_STRUCT: Final[Struct]
+
+class ForkServer:
+    if sys.version_info >= (3, 15):
+        def set_forkserver_preload(
+            self, modules_names: list[str], *, on_error: Literal["ignore", "warn", "fail"] = "ignore"
+        ) -> None: ...
+    else:
+        def set_forkserver_preload(self, modules_names: list[str]) -> None: ...
+
+    def get_inherited_fds(self) -> list[int] | None: ...
+    def connect_to_new_process(self, fds: Sequence[int]) -> tuple[int, int]: ...
+    def ensure_running(self) -> None: ...
+
+if sys.version_info >= (3, 15):
+    def main(
+        listener_fd: int | None,
+        alive_r: FileDescriptorLike,
+        preload: Sequence[str],
+        main_path: str | None = None,
+        sys_path: list[str] | None = None,
+        *,
+        sys_argv: list[str] | None = None,
+        authkey_r: int | None = None,
+        on_error: str = "ignore",
+    ) -> None: ...
+
+elif sys.version_info >= (3, 14):
+    # `sys_argv` parameter added in Python 3.14.3
+    def main(
+        listener_fd: int | None,
+        alive_r: FileDescriptorLike,
+        preload: Sequence[str],
+        main_path: str | None = None,
+        sys_path: list[str] | None = None,
+        *,
+        sys_argv: list[str] | None = None,
+        authkey_r: int | None = None,
+    ) -> None: ...
+
+elif sys.version_info >= (3, 13):
+    # `sys_argv` parameter added in Python 3.13.12
+    def main(
+        listener_fd: int | None,
+        alive_r: FileDescriptorLike,
+        preload: Sequence[str],
+        main_path: str | None = None,
+        sys_path: list[str] | None = None,
+        *,
+        sys_argv: list[str] | None = None,
+    ) -> None: ...
+
+else:
+    def main(
+        listener_fd: int | None,
+        alive_r: FileDescriptorLike,
+        preload: Sequence[str],
+        main_path: str | None = None,
+        sys_path: Unused = None,
+    ) -> None: ...
+
+def read_signed(fd: int) -> Any: ...
+def write_signed(fd: int, n: int) -> None: ...
+
+_forkserver: ForkServer
+ensure_running = _forkserver.ensure_running
+get_inherited_fds = _forkserver.get_inherited_fds
+connect_to_new_process = _forkserver.connect_to_new_process
+set_forkserver_preload = _forkserver.set_forkserver_preload

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

@@ -0,0 +1,41 @@
+import sys
+from collections.abc import Callable
+from mmap import mmap
+from multiprocessing import popen_forkserver, popen_spawn_posix, resource_sharer
+from typing import Protocol, TypeAlias, type_check_only
+
+__all__ = ["BufferWrapper"]
+
+class Arena:
+    size: int
+    buffer: mmap
+    if sys.platform == "win32":
+        name: str
+        def __init__(self, size: int) -> None: ...
+    else:
+        fd: int
+        def __init__(self, size: int, fd: int = -1) -> None: ...
+
+_Block: TypeAlias = tuple[Arena, int, int]
+
+if sys.platform != "win32":
+    @type_check_only
+    class _SupportsDetach(Protocol):
+        def detach(self) -> int: ...
+
+    def reduce_arena(
+        a: Arena,
+    ) -> tuple[
+        Callable[[int, _SupportsDetach], Arena],
+        tuple[int, popen_forkserver._DupFd | popen_spawn_posix._DupFd | resource_sharer.DupFd],
+    ]: ...
+    def rebuild_arena(size: int, dupfd: _SupportsDetach) -> Arena: ...
+
+class Heap:
+    def __init__(self, size: int = ...) -> None: ...
+    def free(self, block: _Block) -> None: ...
+    def malloc(self, size: int) -> _Block: ...
+
+class BufferWrapper:
+    def __init__(self, size: int) -> None: ...
+    def create_memoryview(self) -> memoryview: ...