basedpyright 1.1.389 → 1.1.392

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

@@ -1,18 +1,18 @@
-from _typeshed import FileDescriptorOrPath
-from collections.abc import Sized
-
-__all__ = ["ensure_running", "register", "unregister"]
-
-class ResourceTracker:
-    def getfd(self) -> int | None: ...
-    def ensure_running(self) -> None: ...
-    def register(self, name: Sized, rtype: str) -> None: ...
-    def unregister(self, name: Sized, rtype: str) -> None: ...
-
-_resource_tracker: ResourceTracker
-ensure_running = _resource_tracker.ensure_running
-register = _resource_tracker.register
-unregister = _resource_tracker.unregister
-getfd = _resource_tracker.getfd
-
-def main(fd: FileDescriptorOrPath) -> None: ...
+from _typeshed import FileDescriptorOrPath
+from collections.abc import Sized
+
+__all__ = ["ensure_running", "register", "unregister"]
+
+class ResourceTracker:
+    def getfd(self) -> int | None: ...
+    def ensure_running(self) -> None: ...
+    def register(self, name: Sized, rtype: str) -> None: ...
+    def unregister(self, name: Sized, rtype: str) -> None: ...
+
+_resource_tracker: ResourceTracker
+ensure_running = _resource_tracker.ensure_running
+register = _resource_tracker.register
+unregister = _resource_tracker.unregister
+getfd = _resource_tracker.getfd
+
+def main(fd: FileDescriptorOrPath) -> None: ...

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

@@ -1,58 +1,58 @@
-import sys
-from collections.abc import Iterable
-from typing import Any, Generic, TypeVar, overload
-from typing_extensions import Self
-
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
-__all__ = ["SharedMemory", "ShareableList"]
-
-_SLT = TypeVar("_SLT", int, float, bool, str, bytes, None)
-
-class SharedMemory:
-    if sys.version_info >= (3, 13):
-        def __init__(self, name: str | None = None, create: bool = False, size: int = 0, *, track: bool = True) -> None: ...
-    else:
-        def __init__(self, name: str | None = None, create: bool = False, size: int = 0) -> None: ...
-
-    @property
-    def buf(self) -> memoryview:
-        """A memoryview of contents of the shared memory block."""
-        ...
-    @property
-    def name(self) -> str:
-        """Unique name that identifies the shared memory block."""
-        ...
-    @property
-    def size(self) -> int:
-        """Size in bytes."""
-        ...
-    def close(self) -> None: ...
-    def unlink(self) -> None: ...
-    def __del__(self) -> None: ...
-
-class ShareableList(Generic[_SLT]):
-    shm: SharedMemory
-    @overload
-    def __init__(self, sequence: None = None, *, name: str | None = None) -> None: ...
-    @overload
-    def __init__(self, sequence: Iterable[_SLT], *, name: str | None = None) -> None: ...
-    def __getitem__(self, position: int) -> _SLT: ...
-    def __setitem__(self, position: int, value: _SLT) -> None: ...
-    def __reduce__(self) -> tuple[Self, tuple[_SLT, ...]]: ...
-    def __len__(self) -> int: ...
-    @property
-    def format(self) -> str:
-        """The struct packing format used by all currently stored items."""
-        ...
-    def count(self, value: _SLT) -> int: ...
-    def index(self, value: _SLT) -> int: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
-            """
-            Represent a PEP 585 generic type
-
-            E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
-            """
-            ...
+import sys
+from collections.abc import Iterable
+from typing import Any, Generic, TypeVar, overload
+from typing_extensions import Self
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+__all__ = ["SharedMemory", "ShareableList"]
+
+_SLT = TypeVar("_SLT", int, float, bool, str, bytes, None)
+
+class SharedMemory:
+    if sys.version_info >= (3, 13):
+        def __init__(self, name: str | None = None, create: bool = False, size: int = 0, *, track: bool = True) -> None: ...
+    else:
+        def __init__(self, name: str | None = None, create: bool = False, size: int = 0) -> None: ...
+
+    @property
+    def buf(self) -> memoryview:
+        """A memoryview of contents of the shared memory block."""
+        ...
+    @property
+    def name(self) -> str:
+        """Unique name that identifies the shared memory block."""
+        ...
+    @property
+    def size(self) -> int:
+        """Size in bytes."""
+        ...
+    def close(self) -> None: ...
+    def unlink(self) -> None: ...
+    def __del__(self) -> None: ...
+
+class ShareableList(Generic[_SLT]):
+    shm: SharedMemory
+    @overload
+    def __init__(self, sequence: None = None, *, name: str | None = None) -> None: ...
+    @overload
+    def __init__(self, sequence: Iterable[_SLT], *, name: str | None = None) -> None: ...
+    def __getitem__(self, position: int) -> _SLT: ...
+    def __setitem__(self, position: int, value: _SLT) -> None: ...
+    def __reduce__(self) -> tuple[Self, tuple[_SLT, ...]]: ...
+    def __len__(self) -> int: ...
+    @property
+    def format(self) -> str:
+        """The struct packing format used by all currently stored items."""
+        ...
+    def count(self, value: _SLT) -> int: ...
+    def index(self, value: _SLT) -> int: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+            """
+            Represent a PEP 585 generic type
+
+            E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
+            """
+            ...

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

@@ -1,128 +1,129 @@
-import ctypes
-from collections.abc import Callable, Iterable, Sequence
-from ctypes import _CData, _SimpleCData, c_char
-from multiprocessing.context import BaseContext
-from multiprocessing.synchronize import _LockLike
-from types import TracebackType
-from typing import Any, Generic, Literal, Protocol, TypeVar, overload
-
-__all__ = ["RawValue", "RawArray", "Value", "Array", "copy", "synchronized"]
-
-_T = TypeVar("_T")
-_CT = TypeVar("_CT", bound=_CData)
-
-@overload
-def RawValue(typecode_or_type: type[_CT], *args: Any) -> _CT: ...
-@overload
-def RawValue(typecode_or_type: str, *args: Any) -> Any: ...
-@overload
-def RawArray(typecode_or_type: type[_CT], size_or_initializer: int | Sequence[Any]) -> ctypes.Array[_CT]: ...
-@overload
-def RawArray(typecode_or_type: str, size_or_initializer: int | Sequence[Any]) -> Any: ...
-@overload
-def Value(typecode_or_type: type[_CT], *args: Any, lock: Literal[False], ctx: BaseContext | None = None) -> _CT: ...
-@overload
-def Value(
-    typecode_or_type: type[_CT], *args: Any, lock: Literal[True] | _LockLike = True, ctx: BaseContext | None = None
-) -> SynchronizedBase[_CT]: ...
-@overload
-def Value(
-    typecode_or_type: str, *args: Any, lock: Literal[True] | _LockLike = True, ctx: BaseContext | None = None
-) -> SynchronizedBase[Any]: ...
-@overload
-def Value(
-    typecode_or_type: str | type[_CData], *args: Any, lock: bool | _LockLike = True, ctx: BaseContext | None = None
-) -> Any: ...
-@overload
-def Array(
-    typecode_or_type: type[_CT], size_or_initializer: int | Sequence[Any], *, lock: Literal[False], ctx: BaseContext | None = None
-) -> _CT: ...
-@overload
-def Array(
-    typecode_or_type: type[c_char],
-    size_or_initializer: int | Sequence[Any],
-    *,
-    lock: Literal[True] | _LockLike = True,
-    ctx: BaseContext | None = None,
-) -> SynchronizedString: ...
-@overload
-def Array(
-    typecode_or_type: type[_SimpleCData[_T]],
-    size_or_initializer: int | Sequence[Any],
-    *,
-    lock: Literal[True] | _LockLike = True,
-    ctx: BaseContext | None = None,
-) -> SynchronizedArray[_T]: ...
-@overload
-def Array(
-    typecode_or_type: str,
-    size_or_initializer: int | Sequence[Any],
-    *,
-    lock: Literal[True] | _LockLike = True,
-    ctx: BaseContext | None = None,
-) -> SynchronizedArray[Any]: ...
-@overload
-def Array(
-    typecode_or_type: str | type[_CData],
-    size_or_initializer: int | Sequence[Any],
-    *,
-    lock: bool | _LockLike = True,
-    ctx: BaseContext | None = None,
-) -> Any: ...
-def copy(obj: _CT) -> _CT: ...
-@overload
-def synchronized(obj: _SimpleCData[_T], lock: _LockLike | None = None, ctx: Any | None = None) -> Synchronized[_T]: ...
-@overload
-def synchronized(obj: ctypes.Array[c_char], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedString: ...
-@overload
-def synchronized(
-    obj: ctypes.Array[_SimpleCData[_T]], lock: _LockLike | None = None, ctx: Any | None = None
-) -> SynchronizedArray[_T]: ...
-@overload
-def synchronized(obj: _CT, lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedBase[_CT]: ...
-
-class _AcquireFunc(Protocol):
-    def __call__(self, block: bool = ..., timeout: float | None = ..., /) -> bool: ...
-
-class SynchronizedBase(Generic[_CT]):
-    acquire: _AcquireFunc
-    release: Callable[[], None]
-    def __init__(self, obj: Any, lock: _LockLike | None = None, ctx: Any | None = None) -> None: ...
-    def __reduce__(self) -> tuple[Callable[[Any, _LockLike], SynchronizedBase[Any]], tuple[Any, _LockLike]]: ...
-    def get_obj(self) -> _CT: ...
-    def get_lock(self) -> _LockLike: ...
-    def __enter__(self) -> bool: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None, /
-    ) -> None: ...
-
-class Synchronized(SynchronizedBase[_SimpleCData[_T]], Generic[_T]):
-    value: _T
-
-class SynchronizedArray(SynchronizedBase[ctypes.Array[_SimpleCData[_T]]], Generic[_T]):
-    def __len__(self) -> int: ...
-    @overload
-    def __getitem__(self, i: slice) -> list[_T]: ...
-    @overload
-    def __getitem__(self, i: int) -> _T: ...
-    @overload
-    def __setitem__(self, i: slice, value: Iterable[_T]) -> None: ...
-    @overload
-    def __setitem__(self, i: int, value: _T) -> None: ...
-    def __getslice__(self, start: int, stop: int) -> list[_T]: ...
-    def __setslice__(self, start: int, stop: int, values: Iterable[_T]) -> None: ...
-
-class SynchronizedString(SynchronizedArray[bytes]):
-    @overload  # type: ignore[override]
-    def __getitem__(self, i: slice) -> bytes: ...
-    @overload
-    def __getitem__(self, i: int) -> bytes: ...
-    @overload  # type: ignore[override]
-    def __setitem__(self, i: slice, value: bytes) -> None: ...
-    @overload
-    def __setitem__(self, i: int, value: bytes) -> None: ...
-    def __getslice__(self, start: int, stop: int) -> bytes: ...  # type: ignore[override]
-    def __setslice__(self, start: int, stop: int, values: bytes) -> None: ...  # type: ignore[override]
-
-    value: bytes
-    raw: bytes
+import ctypes
+from _ctypes import _CData
+from collections.abc import Callable, Iterable, Sequence
+from ctypes import _SimpleCData, c_char
+from multiprocessing.context import BaseContext
+from multiprocessing.synchronize import _LockLike
+from types import TracebackType
+from typing import Any, Generic, Literal, Protocol, TypeVar, overload
+
+__all__ = ["RawValue", "RawArray", "Value", "Array", "copy", "synchronized"]
+
+_T = TypeVar("_T")
+_CT = TypeVar("_CT", bound=_CData)
+
+@overload
+def RawValue(typecode_or_type: type[_CT], *args: Any) -> _CT: ...
+@overload
+def RawValue(typecode_or_type: str, *args: Any) -> Any: ...
+@overload
+def RawArray(typecode_or_type: type[_CT], size_or_initializer: int | Sequence[Any]) -> ctypes.Array[_CT]: ...
+@overload
+def RawArray(typecode_or_type: str, size_or_initializer: int | Sequence[Any]) -> Any: ...
+@overload
+def Value(typecode_or_type: type[_CT], *args: Any, lock: Literal[False], ctx: BaseContext | None = None) -> _CT: ...
+@overload
+def Value(
+    typecode_or_type: type[_CT], *args: Any, lock: Literal[True] | _LockLike = True, ctx: BaseContext | None = None
+) -> SynchronizedBase[_CT]: ...
+@overload
+def Value(
+    typecode_or_type: str, *args: Any, lock: Literal[True] | _LockLike = True, ctx: BaseContext | None = None
+) -> SynchronizedBase[Any]: ...
+@overload
+def Value(
+    typecode_or_type: str | type[_CData], *args: Any, lock: bool | _LockLike = True, ctx: BaseContext | None = None
+) -> Any: ...
+@overload
+def Array(
+    typecode_or_type: type[_CT], size_or_initializer: int | Sequence[Any], *, lock: Literal[False], ctx: BaseContext | None = None
+) -> _CT: ...
+@overload
+def Array(
+    typecode_or_type: type[c_char],
+    size_or_initializer: int | Sequence[Any],
+    *,
+    lock: Literal[True] | _LockLike = True,
+    ctx: BaseContext | None = None,
+) -> SynchronizedString: ...
+@overload
+def Array(
+    typecode_or_type: type[_SimpleCData[_T]],
+    size_or_initializer: int | Sequence[Any],
+    *,
+    lock: Literal[True] | _LockLike = True,
+    ctx: BaseContext | None = None,
+) -> SynchronizedArray[_T]: ...
+@overload
+def Array(
+    typecode_or_type: str,
+    size_or_initializer: int | Sequence[Any],
+    *,
+    lock: Literal[True] | _LockLike = True,
+    ctx: BaseContext | None = None,
+) -> SynchronizedArray[Any]: ...
+@overload
+def Array(
+    typecode_or_type: str | type[_CData],
+    size_or_initializer: int | Sequence[Any],
+    *,
+    lock: bool | _LockLike = True,
+    ctx: BaseContext | None = None,
+) -> Any: ...
+def copy(obj: _CT) -> _CT: ...
+@overload
+def synchronized(obj: _SimpleCData[_T], lock: _LockLike | None = None, ctx: Any | None = None) -> Synchronized[_T]: ...
+@overload
+def synchronized(obj: ctypes.Array[c_char], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedString: ...
+@overload
+def synchronized(
+    obj: ctypes.Array[_SimpleCData[_T]], lock: _LockLike | None = None, ctx: Any | None = None
+) -> SynchronizedArray[_T]: ...
+@overload
+def synchronized(obj: _CT, lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedBase[_CT]: ...
+
+class _AcquireFunc(Protocol):
+    def __call__(self, block: bool = ..., timeout: float | None = ..., /) -> bool: ...
+
+class SynchronizedBase(Generic[_CT]):
+    acquire: _AcquireFunc
+    release: Callable[[], None]
+    def __init__(self, obj: Any, lock: _LockLike | None = None, ctx: Any | None = None) -> None: ...
+    def __reduce__(self) -> tuple[Callable[[Any, _LockLike], SynchronizedBase[Any]], tuple[Any, _LockLike]]: ...
+    def get_obj(self) -> _CT: ...
+    def get_lock(self) -> _LockLike: ...
+    def __enter__(self) -> bool: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None, /
+    ) -> None: ...
+
+class Synchronized(SynchronizedBase[_SimpleCData[_T]], Generic[_T]):
+    value: _T
+
+class SynchronizedArray(SynchronizedBase[ctypes.Array[_SimpleCData[_T]]], Generic[_T]):
+    def __len__(self) -> int: ...
+    @overload
+    def __getitem__(self, i: slice) -> list[_T]: ...
+    @overload
+    def __getitem__(self, i: int) -> _T: ...
+    @overload
+    def __setitem__(self, i: slice, value: Iterable[_T]) -> None: ...
+    @overload
+    def __setitem__(self, i: int, value: _T) -> None: ...
+    def __getslice__(self, start: int, stop: int) -> list[_T]: ...
+    def __setslice__(self, start: int, stop: int, values: Iterable[_T]) -> None: ...
+
+class SynchronizedString(SynchronizedArray[bytes]):
+    @overload  # type: ignore[override]
+    def __getitem__(self, i: slice) -> bytes: ...
+    @overload
+    def __getitem__(self, i: int) -> bytes: ...
+    @overload  # type: ignore[override]
+    def __setitem__(self, i: slice, value: bytes) -> None: ...
+    @overload
+    def __setitem__(self, i: int, value: bytes) -> None: ...
+    def __getslice__(self, start: int, stop: int) -> bytes: ...  # type: ignore[override]
+    def __setslice__(self, start: int, stop: int, values: bytes) -> None: ...  # type: ignore[override]
+
+    value: bytes
+    raw: bytes

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

@@ -1,32 +1,32 @@
-from collections.abc import Mapping, Sequence
-from types import ModuleType
-from typing import Any, Final
-
-__all__ = [
-    "_main",
-    "freeze_support",
-    "set_executable",
-    "get_executable",
-    "get_preparation_data",
-    "get_command_line",
-    "import_main_path",
-]
-
-WINEXE: Final[bool]
-WINSERVICE: Final[bool]
-
-def set_executable(exe: str) -> None: ...
-def get_executable() -> str: ...
-def is_forking(argv: Sequence[str]) -> bool: ...
-def freeze_support() -> None: ...
-def get_command_line(**kwds: Any) -> list[str]: ...
-def spawn_main(pipe_handle: int, parent_pid: int | None = None, tracker_fd: int | None = None) -> None: ...
-
-# undocumented
-def _main(fd: int, parent_sentinel: int) -> int: ...
-def get_preparation_data(name: str) -> dict[str, Any]: ...
-
-old_main_modules: list[ModuleType]
-
-def prepare(data: Mapping[str, Any]) -> None: ...
-def import_main_path(main_path: str) -> None: ...
+from collections.abc import Mapping, Sequence
+from types import ModuleType
+from typing import Any, Final
+
+__all__ = [
+    "_main",
+    "freeze_support",
+    "set_executable",
+    "get_executable",
+    "get_preparation_data",
+    "get_command_line",
+    "import_main_path",
+]
+
+WINEXE: Final[bool]
+WINSERVICE: Final[bool]
+
+def set_executable(exe: str) -> None: ...
+def get_executable() -> str: ...
+def is_forking(argv: Sequence[str]) -> bool: ...
+def freeze_support() -> None: ...
+def get_command_line(**kwds: Any) -> list[str]: ...
+def spawn_main(pipe_handle: int, parent_pid: int | None = None, tracker_fd: int | None = None) -> None: ...
+
+# undocumented
+def _main(fd: int, parent_sentinel: int) -> int: ...
+def get_preparation_data(name: str) -> dict[str, Any]: ...
+
+old_main_modules: list[ModuleType]
+
+def prepare(data: Mapping[str, Any]) -> None: ...
+def import_main_path(main_path: str) -> None: ...

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

@@ -1,55 +1,59 @@
-import threading
-from collections.abc import Callable
-from multiprocessing.context import BaseContext
-from types import TracebackType
-from typing_extensions import TypeAlias
-
-__all__ = ["Lock", "RLock", "Semaphore", "BoundedSemaphore", "Condition", "Event"]
-
-_LockLike: TypeAlias = Lock | RLock
-
-class Barrier(threading.Barrier):
-    def __init__(
-        self, parties: int, action: Callable[[], object] | None = None, timeout: float | None = None, *ctx: BaseContext
-    ) -> None: ...
-
-class Condition:
-    def __init__(self, lock: _LockLike | None = None, *, ctx: BaseContext) -> None: ...
-    def notify(self, n: int = 1) -> None: ...
-    def notify_all(self) -> None: ...
-    def wait(self, timeout: float | None = None) -> bool: ...
-    def wait_for(self, predicate: Callable[[], bool], timeout: float | None = None) -> bool: ...
-    def acquire(self, block: bool = ..., timeout: float | None = ...) -> bool: ...
-    def release(self) -> None: ...
-    def __enter__(self) -> bool: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None, /
-    ) -> None: ...
-
-class Event:
-    def __init__(self, *, ctx: BaseContext) -> None: ...
-    def is_set(self) -> bool: ...
-    def set(self) -> None: ...
-    def clear(self) -> None: ...
-    def wait(self, timeout: float | None = None) -> bool: ...
-
-# Not part of public API
-class SemLock:
-    def acquire(self, block: bool = ..., timeout: float | None = ...) -> bool: ...
-    def release(self) -> None: ...
-    def __enter__(self) -> bool: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None, /
-    ) -> None: ...
-
-class Lock(SemLock):
-    def __init__(self, *, ctx: BaseContext) -> None: ...
-
-class RLock(SemLock):
-    def __init__(self, *, ctx: BaseContext) -> None: ...
-
-class Semaphore(SemLock):
-    def __init__(self, value: int = 1, *, ctx: BaseContext) -> None: ...
-
-class BoundedSemaphore(Semaphore):
-    def __init__(self, value: int = 1, *, ctx: BaseContext) -> None: ...
+import threading
+from collections.abc import Callable
+from multiprocessing.context import BaseContext
+from types import TracebackType
+from typing_extensions import TypeAlias
+
+__all__ = ["Lock", "RLock", "Semaphore", "BoundedSemaphore", "Condition", "Event"]
+
+_LockLike: TypeAlias = Lock | RLock
+
+class Barrier(threading.Barrier):
+    def __init__(
+        self, parties: int, action: Callable[[], object] | None = None, timeout: float | None = None, *, ctx: BaseContext
+    ) -> None: ...
+
+class Condition:
+    def __init__(self, lock: _LockLike | None = None, *, ctx: BaseContext) -> None: ...
+    def notify(self, n: int = 1) -> None: ...
+    def notify_all(self) -> None: ...
+    def wait(self, timeout: float | None = None) -> bool: ...
+    def wait_for(self, predicate: Callable[[], bool], timeout: float | None = None) -> bool: ...
+    def __enter__(self) -> bool: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None, /
+    ) -> None: ...
+    # These methods are copied from the lock passed to the constructor, or an
+    # instance of ctx.RLock() if lock was None.
+    def acquire(self, block: bool = True, timeout: float | None = None) -> bool: ...
+    def release(self) -> None: ...
+
+class Event:
+    def __init__(self, *, ctx: BaseContext) -> None: ...
+    def is_set(self) -> bool: ...
+    def set(self) -> None: ...
+    def clear(self) -> None: ...
+    def wait(self, timeout: float | None = None) -> bool: ...
+
+# Not part of public API
+class SemLock:
+    def __init__(self, kind: int, value: int, maxvalue: int, *, ctx: BaseContext | None) -> None: ...
+    def __enter__(self) -> bool: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None, /
+    ) -> None: ...
+    # These methods are copied from the wrapped _multiprocessing.SemLock object
+    def acquire(self, block: bool = True, timeout: float | None = None) -> bool: ...
+    def release(self) -> None: ...
+
+class Lock(SemLock):
+    def __init__(self, *, ctx: BaseContext) -> None: ...
+
+class RLock(SemLock):
+    def __init__(self, *, ctx: BaseContext) -> None: ...
+
+class Semaphore(SemLock):
+    def __init__(self, value: int = 1, *, ctx: BaseContext) -> None: ...
+
+class BoundedSemaphore(Semaphore):
+    def __init__(self, value: int = 1, *, ctx: BaseContext) -> None: ...