jaclang 0.7.34__py3-none-any.whl → 0.8.1__py3-none-any.whl

jaclang/vendor/mypy/typeshed/stdlib/multiprocessing/dummy/__init__.pyi

@@ -1,77 +0,0 @@
-import array
-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: ...
-    def __init__(
-        self,
-        group: Any = None,
-        target: Callable[..., object] | None = None,
-        name: str | None = None,
-        args: Iterable[Any] = (),
-        kwargs: Mapping[str, Any] = {},
-    ) -> 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: ...

jaclang/vendor/mypy/typeshed/stdlib/multiprocessing/dummy/connection.pyi

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

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

@@ -1,31 +0,0 @@
-from _typeshed import FileDescriptorLike, Unused
-from collections.abc import Sequence
-from struct import Struct
-from typing import Any
-
-__all__ = ["ensure_running", "get_inherited_fds", "connect_to_new_process", "set_forkserver_preload"]
-
-MAXFDS_TO_SEND: int
-SIGNED_STRUCT: Struct
-
-class ForkServer:
-    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: ...
-
-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

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

@@ -1,36 +0,0 @@
-import sys
-from _typeshed import Incomplete
-from collections.abc import Callable
-from mmap import mmap
-from typing import Protocol
-from typing_extensions import TypeAlias
-
-__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":
-    class _SupportsDetach(Protocol):
-        def detach(self) -> int: ...
-
-    def reduce_arena(a: Arena) -> tuple[Callable[[int, _SupportsDetach], Arena], tuple[int, Incomplete]]: ...
-    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: ...

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

@@ -1,212 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

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

@@ -1,30 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

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