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

jaclang/vendor/mypy/typeshed/stdlib/msilib/__init__.pyi

@@ -0,0 +1,177 @@
+import sys
+from collections.abc import Container, Iterable, Sequence
+from types import ModuleType
+from typing import Any, Literal
+
+if sys.platform == "win32":
+    from _msi import *
+    from _msi import _Database
+
+    AMD64: bool
+    Win64: bool
+
+    datasizemask: Literal[0x00FF]
+    type_valid: Literal[0x0100]
+    type_localizable: Literal[0x0200]
+    typemask: Literal[0x0C00]
+    type_long: Literal[0x0000]
+    type_short: Literal[0x0400]
+    type_string: Literal[0x0C00]
+    type_binary: Literal[0x0800]
+    type_nullable: Literal[0x1000]
+    type_key: Literal[0x2000]
+    knownbits: Literal[0x3FFF]
+
+    class Table:
+        name: str
+        fields: list[tuple[int, str, int]]
+        def __init__(self, name: str) -> None: ...
+        def add_field(self, index: int, name: str, type: int) -> None: ...
+        def sql(self) -> str: ...
+        def create(self, db: _Database) -> None: ...
+
+    class _Unspecified: ...
+
+    def change_sequence(
+        seq: Sequence[tuple[str, str | None, int]],
+        action: str,
+        seqno: int | type[_Unspecified] = ...,
+        cond: str | type[_Unspecified] = ...,
+    ) -> None: ...
+    def add_data(db: _Database, table: str, values: Iterable[tuple[Any, ...]]) -> None: ...
+    def add_stream(db: _Database, name: str, path: str) -> None: ...
+    def init_database(
+        name: str, schema: ModuleType, ProductName: str, ProductCode: str, ProductVersion: str, Manufacturer: str
+    ) -> _Database: ...
+    def add_tables(db: _Database, module: ModuleType) -> None: ...
+    def make_id(str: str) -> str: ...
+    def gen_uuid() -> str: ...
+
+    class CAB:
+        name: str
+        files: list[tuple[str, str]]
+        filenames: set[str]
+        index: int
+        def __init__(self, name: str) -> None: ...
+        def gen_id(self, file: str) -> str: ...
+        def append(self, full: str, file: str, logical: str) -> tuple[int, str]: ...
+        def commit(self, db: _Database) -> None: ...
+
+    _directories: set[str]
+
+    class Directory:
+        db: _Database
+        cab: CAB
+        basedir: str
+        physical: str
+        logical: str
+        component: str | None
+        short_names: set[str]
+        ids: set[str]
+        keyfiles: dict[str, str]
+        componentflags: int | None
+        absolute: str
+        def __init__(
+            self,
+            db: _Database,
+            cab: CAB,
+            basedir: str,
+            physical: str,
+            _logical: str,
+            default: str,
+            componentflags: int | None = None,
+        ) -> None: ...
+        def start_component(
+            self,
+            component: str | None = None,
+            feature: Feature | None = None,
+            flags: int | None = None,
+            keyfile: str | None = None,
+            uuid: str | None = None,
+        ) -> None: ...
+        def make_short(self, file: str) -> str: ...
+        def add_file(self, file: str, src: str | None = None, version: str | None = None, language: str | None = None) -> str: ...
+        def glob(self, pattern: str, exclude: Container[str] | None = None) -> list[str]: ...
+        def remove_pyc(self) -> None: ...
+
+    class Binary:
+        name: str
+        def __init__(self, fname: str) -> None: ...
+
+    class Feature:
+        id: str
+        def __init__(
+            self,
+            db: _Database,
+            id: str,
+            title: str,
+            desc: str,
+            display: int,
+            level: int = 1,
+            parent: Feature | None = None,
+            directory: str | None = None,
+            attributes: int = 0,
+        ) -> None: ...
+        def set_current(self) -> None: ...
+
+    class Control:
+        dlg: Dialog
+        name: str
+        def __init__(self, dlg: Dialog, name: str) -> None: ...
+        def event(self, event: str, argument: str, condition: str = "1", ordering: int | None = None) -> None: ...
+        def mapping(self, event: str, attribute: str) -> None: ...
+        def condition(self, action: str, condition: str) -> None: ...
+
+    class RadioButtonGroup(Control):
+        property: str
+        index: int
+        def __init__(self, dlg: Dialog, name: str, property: str) -> None: ...
+        def add(self, name: str, x: int, y: int, w: int, h: int, text: str, value: str | None = None) -> None: ...
+
+    class Dialog:
+        db: _Database
+        name: str
+        x: int
+        y: int
+        w: int
+        h: int
+        def __init__(
+            self,
+            db: _Database,
+            name: str,
+            x: int,
+            y: int,
+            w: int,
+            h: int,
+            attr: int,
+            title: str,
+            first: str,
+            default: str,
+            cancel: str,
+        ) -> None: ...
+        def control(
+            self,
+            name: str,
+            type: str,
+            x: int,
+            y: int,
+            w: int,
+            h: int,
+            attr: int,
+            prop: str | None,
+            text: str | None,
+            next: str | None,
+            help: str | None,
+        ) -> Control: ...
+        def text(self, name: str, x: int, y: int, w: int, h: int, attr: int, text: str | None) -> Control: ...
+        def bitmap(self, name: str, x: int, y: int, w: int, h: int, text: str | None) -> Control: ...
+        def line(self, name: str, x: int, y: int, w: int, h: int) -> Control: ...
+        def pushbutton(
+            self, name: str, x: int, y: int, w: int, h: int, attr: int, text: str | None, next: str | None
+        ) -> Control: ...
+        def radiogroup(
+            self, name: str, x: int, y: int, w: int, h: int, attr: int, prop: str | None, text: str | None, next: str | None
+        ) -> RadioButtonGroup: ...
+        def checkbox(
+            self, name: str, x: int, y: int, w: int, h: int, attr: int, prop: str | None, text: str | None, next: str | None
+        ) -> Control: ...

jaclang/vendor/mypy/typeshed/stdlib/msilib/schema.pyi

@@ -0,0 +1,94 @@
+import sys
+
+if sys.platform == "win32":
+    from . import Table
+
+    _Validation: Table
+    ActionText: Table
+    AdminExecuteSequence: Table
+    Condition: Table
+    AdminUISequence: Table
+    AdvtExecuteSequence: Table
+    AdvtUISequence: Table
+    AppId: Table
+    AppSearch: Table
+    Property: Table
+    BBControl: Table
+    Billboard: Table
+    Feature: Table
+    Binary: Table
+    BindImage: Table
+    File: Table
+    CCPSearch: Table
+    CheckBox: Table
+    Class: Table
+    Component: Table
+    Icon: Table
+    ProgId: Table
+    ComboBox: Table
+    CompLocator: Table
+    Complus: Table
+    Directory: Table
+    Control: Table
+    Dialog: Table
+    ControlCondition: Table
+    ControlEvent: Table
+    CreateFolder: Table
+    CustomAction: Table
+    DrLocator: Table
+    DuplicateFile: Table
+    Environment: Table
+    Error: Table
+    EventMapping: Table
+    Extension: Table
+    MIME: Table
+    FeatureComponents: Table
+    FileSFPCatalog: Table
+    SFPCatalog: Table
+    Font: Table
+    IniFile: Table
+    IniLocator: Table
+    InstallExecuteSequence: Table
+    InstallUISequence: Table
+    IsolatedComponent: Table
+    LaunchCondition: Table
+    ListBox: Table
+    ListView: Table
+    LockPermissions: Table
+    Media: Table
+    MoveFile: Table
+    MsiAssembly: Table
+    MsiAssemblyName: Table
+    MsiDigitalCertificate: Table
+    MsiDigitalSignature: Table
+    MsiFileHash: Table
+    MsiPatchHeaders: Table
+    ODBCAttribute: Table
+    ODBCDriver: Table
+    ODBCDataSource: Table
+    ODBCSourceAttribute: Table
+    ODBCTranslator: Table
+    Patch: Table
+    PatchPackage: Table
+    PublishComponent: Table
+    RadioButton: Table
+    Registry: Table
+    RegLocator: Table
+    RemoveFile: Table
+    RemoveIniFile: Table
+    RemoveRegistry: Table
+    ReserveCost: Table
+    SelfReg: Table
+    ServiceControl: Table
+    ServiceInstall: Table
+    Shortcut: Table
+    Signature: Table
+    TextStyle: Table
+    TypeLib: Table
+    UIText: Table
+    Upgrade: Table
+    Verb: Table
+
+    tables: list[Table]
+
+    _Validation_records: list[tuple[str, str, str, int | None, int | None, str | None, int | None, str | None, str | None, str]]

jaclang/vendor/mypy/typeshed/stdlib/msilib/sequence.pyi

@@ -0,0 +1,13 @@
+import sys
+from typing_extensions import TypeAlias
+
+if sys.platform == "win32":
+    _SequenceType: TypeAlias = list[tuple[str, str | None, int]]
+
+    AdminExecuteSequence: _SequenceType
+    AdminUISequence: _SequenceType
+    AdvtExecuteSequence: _SequenceType
+    InstallExecuteSequence: _SequenceType
+    InstallUISequence: _SequenceType
+
+    tables: list[str]

jaclang/vendor/mypy/typeshed/stdlib/msilib/text.pyi

@@ -0,0 +1,7 @@
+import sys
+
+if sys.platform == "win32":
+    ActionText: list[tuple[str, str, str | None]]
+    UIText: list[tuple[str, str | None]]
+    dirname: str
+    tables: list[str]

jaclang/vendor/mypy/typeshed/stdlib/msvcrt.pyi

@@ -0,0 +1,32 @@
+import sys
+from typing import Final, Literal
+
+# This module is only available on Windows
+if sys.platform == "win32":
+    CRT_ASSEMBLY_VERSION: Final[str]
+    LK_UNLCK: Literal[0]
+    LK_LOCK: Literal[1]
+    LK_NBLCK: Literal[2]
+    LK_RLCK: Literal[3]
+    LK_NBRLCK: Literal[4]
+    SEM_FAILCRITICALERRORS: int
+    SEM_NOALIGNMENTFAULTEXCEPT: int
+    SEM_NOGPFAULTERRORBOX: int
+    SEM_NOOPENFILEERRORBOX: int
+    def locking(fd: int, mode: int, nbytes: int, /) -> None: ...
+    def setmode(fd: int, mode: int, /) -> int: ...
+    def open_osfhandle(handle: int, flags: int, /) -> int: ...
+    def get_osfhandle(fd: int, /) -> int: ...
+    def kbhit() -> bool: ...
+    def getch() -> bytes: ...
+    def getwch() -> str: ...
+    def getche() -> bytes: ...
+    def getwche() -> str: ...
+    def putch(char: bytes | bytearray, /) -> None: ...
+    def putwch(unicode_char: str, /) -> None: ...
+    def ungetch(char: bytes | bytearray, /) -> None: ...
+    def ungetwch(unicode_char: str, /) -> None: ...
+    def heapmin() -> None: ...
+    def SetErrorMode(mode: int, /) -> int: ...
+    if sys.version_info >= (3, 10):
+        def GetErrorMode() -> int: ...  # undocumented

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

@@ -0,0 +1,90 @@
+from multiprocessing import context, reduction as reducer
+from multiprocessing.context import (
+    AuthenticationError as AuthenticationError,
+    BufferTooShort as BufferTooShort,
+    Process as Process,
+    ProcessError as ProcessError,
+    TimeoutError as TimeoutError,
+)
+from multiprocessing.process import (
+    active_children as active_children,
+    current_process as current_process,
+    parent_process as parent_process,
+)
+
+# These are technically functions that return instances of these Queue classes.
+# The stub here doesn't reflect reality exactly --
+# while e.g. `multiprocessing.queues.Queue` is a class,
+# `multiprocessing.Queue` is actually a function at runtime.
+# Avoid using `multiprocessing.Queue` as a type annotation;
+# use imports from multiprocessing.queues instead.
+# See #4266 and #8450 for discussion.
+from multiprocessing.queues import JoinableQueue as JoinableQueue, Queue as Queue, SimpleQueue as SimpleQueue
+from multiprocessing.spawn import freeze_support as freeze_support
+
+__all__ = [
+    "Array",
+    "AuthenticationError",
+    "Barrier",
+    "BoundedSemaphore",
+    "BufferTooShort",
+    "Condition",
+    "Event",
+    "JoinableQueue",
+    "Lock",
+    "Manager",
+    "Pipe",
+    "Pool",
+    "Process",
+    "ProcessError",
+    "Queue",
+    "RLock",
+    "RawArray",
+    "RawValue",
+    "Semaphore",
+    "SimpleQueue",
+    "TimeoutError",
+    "Value",
+    "active_children",
+    "allow_connection_pickling",
+    "cpu_count",
+    "current_process",
+    "freeze_support",
+    "get_all_start_methods",
+    "get_context",
+    "get_logger",
+    "get_start_method",
+    "log_to_stderr",
+    "parent_process",
+    "reducer",
+    "set_executable",
+    "set_forkserver_preload",
+    "set_start_method",
+]
+
+# These functions (really bound methods)
+# are all autogenerated at runtime here: https://github.com/python/cpython/blob/600c65c094b0b48704d8ec2416930648052ba715/Lib/multiprocessing/__init__.py#L23
+RawValue = context._default_context.RawValue
+RawArray = context._default_context.RawArray
+Value = context._default_context.Value
+Array = context._default_context.Array
+Barrier = context._default_context.Barrier
+BoundedSemaphore = context._default_context.BoundedSemaphore
+Condition = context._default_context.Condition
+Event = context._default_context.Event
+Lock = context._default_context.Lock
+RLock = context._default_context.RLock
+Semaphore = context._default_context.Semaphore
+Pipe = context._default_context.Pipe
+Pool = context._default_context.Pool
+allow_connection_pickling = context._default_context.allow_connection_pickling
+cpu_count = context._default_context.cpu_count
+get_logger = context._default_context.get_logger
+log_to_stderr = context._default_context.log_to_stderr
+Manager = context._default_context.Manager
+set_executable = context._default_context.set_executable
+set_forkserver_preload = context._default_context.set_forkserver_preload
+get_all_start_methods = context._default_context.get_all_start_methods
+get_start_method = context._default_context.get_start_method
+set_start_method = context._default_context.set_start_method
+get_context = context._default_context.get_context

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

@@ -0,0 +1,75 @@
+import socket
+import sys
+import types
+from _typeshed import ReadableBuffer
+from collections.abc import Iterable
+from typing import Any, SupportsIndex
+from typing_extensions import Self, TypeAlias
+
+__all__ = ["Client", "Listener", "Pipe", "wait"]
+
+# https://docs.python.org/3/library/multiprocessing.html#address-formats
+_Address: TypeAlias = str | tuple[str, int]
+
+class _ConnectionBase:
+    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: Any) -> None: ...
+    def recv_bytes(self, maxlength: int | None = None) -> bytes: ...
+    def recv_bytes_into(self, buf: Any, offset: int = 0) -> int: ...
+    def recv(self) -> Any: ...
+    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: types.TracebackType | None
+    ) -> None: ...
+    def __del__(self) -> None: ...
+
+class Connection(_ConnectionBase): ...
+
+if sys.platform == "win32":
+    class PipeConnection(_ConnectionBase): ...
+
+class Listener:
+    def __init__(
+        self, address: _Address | None = None, family: str | None = None, backlog: int = 1, authkey: bytes | None = None
+    ) -> None: ...
+    def accept(self) -> Connection: ...
+    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: types.TracebackType | None
+    ) -> None: ...
+
+if sys.version_info >= (3, 12):
+    def deliver_challenge(connection: Connection, authkey: bytes, digest_name: str = "sha256") -> None: ...
+
+else:
+    def deliver_challenge(connection: Connection, authkey: bytes) -> None: ...
+
+def answer_challenge(connection: Connection, authkey: bytes) -> None: ...
+def wait(
+    object_list: Iterable[Connection | socket.socket | int], timeout: float | None = None
+) -> list[Connection | socket.socket | int]: ...
+def Client(address: _Address, family: str | None = None, authkey: bytes | None = None) -> Connection: ...
+
+# 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.
+if sys.platform != "win32":
+    def Pipe(duplex: bool = True) -> tuple[Connection, Connection]: ...
+
+else:
+    def Pipe(duplex: bool = True) -> tuple[PipeConnection, PipeConnection]: ...

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

@@ -0,0 +1,189 @@
+import ctypes
+import sys
+from collections.abc import Callable, Iterable, Sequence
+from ctypes import _CData
+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
+from typing import Any, ClassVar, Literal, TypeVar, overload
+from typing_extensions import TypeAlias
+
+if sys.platform != "win32":
+    from multiprocessing.connection import Connection
+else:
+    from multiprocessing.connection import PipeConnection
+
+__all__ = ()
+
+_LockLike: TypeAlias = synchronize.Lock | synchronize.RLock
+_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.
+    if sys.platform != "win32":
+        def Pipe(self, duplex: bool = True) -> tuple[Connection, Connection]: ...
+    else:
+        def Pipe(self, duplex: bool = True) -> tuple[PipeConnection, PipeConnection]: ...
+
+    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[_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[_CT], size_or_initializer: int | Sequence[Any], *, lock: Literal[False]
+    ) -> SynchronizedArray[_CT]: ...
+    @overload
+    def Array(
+        self, typecode_or_type: type[_CT], size_or_initializer: int | Sequence[Any], *, lock: Literal[True] | _LockLike = True
+    ) -> SynchronizedArray[_CT]: ...
+    @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: ...
+    def set_forkserver_preload(self, module_names: list[str]) -> None: ...
+    if sys.platform != "win32":
+        @overload
+        def get_context(self, method: None = None) -> DefaultContext: ...
+        @overload
+        def get_context(self, method: Literal["spawn"]) -> SpawnContext: ...
+        @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: ...
+    else:
+        @overload
+        def get_context(self, method: None = None) -> DefaultContext: ...
+        @overload
+        def get_context(self, method: Literal["spawn"]) -> SpawnContext: ...
+        @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: ...
+def get_spawning_popen() -> Any | None: ...
+def set_spawning_popen(popen: Any) -> None: ...
+def assert_spawning(obj: Any) -> None: ...