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

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

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

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

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

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

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

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

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

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