layermap 0.1.0

package/analyzers/project-map-python/typeshed/stdlib/mmap.pyi

@@ -0,0 +1,187 @@
+import os
+import sys
+from _typeshed import ReadableBuffer, Unused
+from collections.abc import Iterator
+from typing import Final, Literal, NoReturn, SupportsIndex, overload
+from typing_extensions import Self, disjoint_base
+
+ACCESS_DEFAULT: Final = 0
+ACCESS_READ: Final = 1
+ACCESS_WRITE: Final = 2
+ACCESS_COPY: Final = 3
+
+ALLOCATIONGRANULARITY: Final[int]
+
+if sys.platform == "linux":
+    MAP_DENYWRITE: Final[int]
+    MAP_EXECUTABLE: Final[int]
+    MAP_POPULATE: Final[int]
+if sys.version_info >= (3, 11) and sys.platform != "win32" and sys.platform != "darwin":
+    MAP_STACK: Final[int]
+
+if sys.platform != "win32":
+    MAP_ANON: Final[int]
+    MAP_ANONYMOUS: Final[int]
+    MAP_PRIVATE: Final[int]
+    MAP_SHARED: Final[int]
+    PROT_EXEC: Final[int]
+    PROT_READ: Final[int]
+    PROT_WRITE: Final[int]
+    if sys.version_info >= (3, 15):
+        MS_ASYNC: Final[int]
+        MS_INVALIDATE: Final[int]
+        MS_SYNC: Final[int]
+
+PAGESIZE: Final[int]
+
+@disjoint_base
+class mmap:
+    if sys.platform == "win32":
+        if sys.version_info >= (3, 15):
+            def __new__(
+                cls,
+                fileno: int,
+                length: int,
+                tagname: str | None = None,
+                access: int = 0,
+                offset: int = 0,
+                *,
+                trackfd: bool = True,
+            ) -> Self: ...
+        else:
+            def __new__(cls, fileno: int, length: int, tagname: str | None = None, access: int = 0, offset: int = 0) -> Self: ...
+    else:
+        if sys.version_info >= (3, 13):
+            def __new__(
+                cls,
+                fileno: int,
+                length: int,
+                flags: int = ...,
+                prot: int = ...,
+                access: int = 0,
+                offset: int = 0,
+                *,
+                trackfd: bool = True,
+            ) -> Self: ...
+        else:
+            def __new__(
+                cls, fileno: int, length: int, flags: int = ..., prot: int = ..., access: int = 0, offset: int = 0
+            ) -> Self: ...
+
+    def close(self) -> None: ...
+    if sys.version_info >= (3, 15):
+        def flush(self, offset: int = 0, size: int = ..., /, *, flags: int = 0) -> None: ...
+    else:
+        def flush(self, offset: int = 0, size: int = ..., /) -> None: ...
+
+    def move(self, dest: int, src: int, count: int, /) -> None: ...
+    def read_byte(self) -> int: ...
+    def readline(self) -> bytes: ...
+    if sys.version_info < (3, 15) or sys.platform != "darwin":
+        def resize(self, newsize: int, /) -> None: ...
+    if sys.platform != "win32":
+        def seek(self, pos: int, whence: Literal[0, 1, 2, 3, 4] = os.SEEK_SET, /) -> None: ...
+    else:
+        def seek(self, pos: int, whence: Literal[0, 1, 2] = os.SEEK_SET, /) -> None: ...
+
+    def size(self) -> int: ...
+    def tell(self) -> int: ...
+    def write_byte(self, byte: int, /) -> None: ...
+    def __len__(self) -> int: ...
+    closed: bool
+    if sys.platform != "win32":
+        if sys.version_info >= (3, 15):
+            def madvise(self, option: int, start: int = 0, length: int | None = None, /) -> None: ...
+        else:
+            def madvise(self, option: int, start: int = 0, length: int = ..., /) -> None: ...
+
+    if sys.version_info >= (3, 15):
+        def find(self, view: ReadableBuffer, start: int | None = None, end: int | None = None, /) -> int: ...
+        def rfind(self, view: ReadableBuffer, start: int | None = None, end: int | None = None, /) -> int: ...
+
+    else:
+        def find(self, view: ReadableBuffer, start: int = ..., end: int = ..., /) -> int: ...
+        def rfind(self, view: ReadableBuffer, start: int = ..., end: int = ..., /) -> int: ...
+
+    def read(self, n: int | None = None, /) -> bytes: ...
+    def write(self, bytes: ReadableBuffer, /) -> int: ...
+    if sys.version_info >= (3, 15):
+        def set_name(self, name: str, /) -> None: ...
+
+    @overload
+    def __getitem__(self, key: SupportsIndex, /) -> int: ...
+    @overload
+    def __getitem__(self, key: slice[SupportsIndex | None], /) -> bytes: ...
+
+    def __delitem__(self, key: SupportsIndex | slice[SupportsIndex | None], /) -> NoReturn: ...
+
+    @overload
+    def __setitem__(self, key: SupportsIndex, value: int, /) -> None: ...
+    @overload
+    def __setitem__(self, key: slice[SupportsIndex | None], value: ReadableBuffer, /) -> None: ...
+
+    # Doesn't actually exist, but the object actually supports "in" because it has __getitem__,
+    # so we claim that there is also a __contains__ to help type checkers.
+    def __contains__(self, o: object, /) -> bool: ...
+    # Doesn't actually exist, but the object is actually iterable because it has __getitem__ and __len__,
+    # so we claim that there is also an __iter__ to help type checkers.
+    def __iter__(self) -> Iterator[int]: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(self, exc_type: Unused, exc_value: Unused, traceback: Unused, /) -> None: ...
+    def __buffer__(self, flags: int, /) -> memoryview: ...
+    def __release_buffer__(self, buffer: memoryview, /) -> None: ...
+    if sys.version_info >= (3, 13):
+        def seekable(self) -> Literal[True]: ...
+
+if sys.platform != "win32":
+    MADV_NORMAL: Final[int]
+    MADV_RANDOM: Final[int]
+    MADV_SEQUENTIAL: Final[int]
+    MADV_WILLNEED: Final[int]
+    MADV_DONTNEED: Final[int]
+    MADV_FREE: Final[int]
+
+if sys.platform == "linux":
+    MADV_REMOVE: Final[int]
+    MADV_DONTFORK: Final[int]
+    MADV_DOFORK: Final[int]
+    MADV_HWPOISON: Final[int]
+    MADV_MERGEABLE: Final[int]
+    MADV_UNMERGEABLE: Final[int]
+    # Seems like this constant is not defined in glibc.
+    # See https://github.com/python/typeshed/pull/5360 for details
+    # MADV_SOFT_OFFLINE: Final[int]
+    MADV_HUGEPAGE: Final[int]
+    MADV_NOHUGEPAGE: Final[int]
+    MADV_DONTDUMP: Final[int]
+    MADV_DODUMP: Final[int]
+
+# This Values are defined for FreeBSD but type checkers do not support conditions for these
+if sys.platform != "linux" and sys.platform != "darwin" and sys.platform != "win32":
+    MADV_NOSYNC: Final[int]
+    MADV_AUTOSYNC: Final[int]
+    MADV_NOCORE: Final[int]
+    MADV_CORE: Final[int]
+    MADV_PROTECT: Final[int]
+
+if sys.platform == "darwin":
+    MADV_FREE_REUSABLE: Final[int]
+    MADV_FREE_REUSE: Final[int]
+
+if sys.version_info >= (3, 13) and sys.platform != "win32":
+    MAP_32BIT: Final[int]
+
+if sys.version_info >= (3, 13) and sys.platform == "darwin":
+    MAP_NORESERVE: Final = 64
+    MAP_NOEXTEND: Final = 256
+    MAP_HASSEMAPHORE: Final = 512
+    MAP_NOCACHE: Final = 1024
+    MAP_JIT: Final = 2048
+    MAP_RESILIENT_CODESIGN: Final = 8192
+    MAP_RESILIENT_MEDIA: Final = 16384
+    MAP_TRANSLATED_ALLOW_EXECUTE: Final = 131072
+    MAP_UNIX03: Final = 262144
+    MAP_TPRO: Final = 524288
+
+if sys.version_info >= (3, 13) and sys.platform == "linux":
+    MAP_NORESERVE: Final = 16384

package/analyzers/project-map-python/typeshed/stdlib/modulefinder.pyi

@@ -0,0 +1,68 @@
+import sys
+from collections.abc import Container, Iterable, Iterator, Sequence
+from types import CodeType
+from typing import IO, Any, Final
+
+if sys.version_info < (3, 11):
+    LOAD_CONST: Final[int]  # undocumented
+    IMPORT_NAME: Final[int]  # undocumented
+    STORE_NAME: Final[int]  # undocumented
+    STORE_GLOBAL: Final[int]  # undocumented
+    STORE_OPS: Final[tuple[int, int]]  # undocumented
+    EXTENDED_ARG: Final[int]  # undocumented
+
+packagePathMap: dict[str, list[str]]  # undocumented
+
+def AddPackagePath(packagename: str, path: str) -> None: ...
+
+replacePackageMap: dict[str, str]  # undocumented
+
+def ReplacePackage(oldname: str, newname: str) -> None: ...
+
+class Module:  # undocumented
+    def __init__(self, name: str, file: str | None = None, path: str | None = None) -> None: ...
+
+class ModuleFinder:
+    modules: dict[str, Module]
+    path: list[str]  # undocumented
+    badmodules: dict[str, dict[str, int]]  # undocumented
+    debug: int  # undocumented
+    indent: int  # undocumented
+    excludes: Container[str]  # undocumented
+    replace_paths: Sequence[tuple[str, str]]  # undocumented
+
+    def __init__(
+        self,
+        path: list[str] | None = None,
+        debug: int = 0,
+        excludes: Container[str] | None = None,
+        replace_paths: Sequence[tuple[str, str]] | None = None,
+    ) -> None: ...
+    def msg(self, level: int, str: str, *args: Any) -> None: ...  # undocumented
+    def msgin(self, *args: Any) -> None: ...  # undocumented
+    def msgout(self, *args: Any) -> None: ...  # undocumented
+    def run_script(self, pathname: str) -> None: ...
+    def load_file(self, pathname: str) -> None: ...  # undocumented
+    def import_hook(
+        self, name: str, caller: Module | None = None, fromlist: list[str] | None = None, level: int = -1
+    ) -> Module | None: ...  # undocumented
+    def determine_parent(self, caller: Module | None, level: int = -1) -> Module | None: ...  # undocumented
+    def find_head_package(self, parent: Module, name: str) -> tuple[Module, str]: ...  # undocumented
+    def load_tail(self, q: Module, tail: str) -> Module: ...  # undocumented
+    def ensure_fromlist(self, m: Module, fromlist: Iterable[str], recursive: int = 0) -> None: ...  # undocumented
+    def find_all_submodules(self, m: Module) -> Iterable[str]: ...  # undocumented
+    def import_module(self, partname: str, fqname: str, parent: Module) -> Module | None: ...  # undocumented
+    def load_module(self, fqname: str, fp: IO[str], pathname: str, file_info: tuple[str, str, str]) -> Module: ...  # undocumented
+    def scan_opcodes(self, co: CodeType) -> Iterator[tuple[str, tuple[Any, ...]]]: ...  # undocumented
+    def scan_code(self, co: CodeType, m: Module) -> None: ...  # undocumented
+    def load_package(self, fqname: str, pathname: str) -> Module: ...  # undocumented
+    def add_module(self, fqname: str) -> Module: ...  # undocumented
+    def find_module(
+        self, name: str, path: str | None, parent: Module | None = None
+    ) -> tuple[IO[Any] | None, str | None, tuple[str, str, int]]: ...  # undocumented
+    def report(self) -> None: ...
+    def any_missing(self) -> list[str]: ...  # undocumented
+    def any_missing_maybe(self) -> tuple[list[str], list[str]]: ...  # undocumented
+    def replace_paths_in_code(self, co: CodeType) -> CodeType: ...  # undocumented
+
+def test() -> ModuleFinder | None: ...  # undocumented

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

@@ -0,0 +1,177 @@
+import sys
+from _typeshed import MaybeNone
+from collections.abc import Container, Iterable
+from types import ModuleType
+from typing import Any, Final
+
+if sys.platform == "win32":
+    from _msi import *
+    from _msi import _Database
+
+    from .sequence import _SequenceType
+
+    AMD64: Final[bool]
+    Win64: Final[bool]
+
+    datasizemask: Final = 0x00FF
+    type_valid: Final = 0x0100
+    type_localizable: Final = 0x0200
+    typemask: Final = 0x0C00
+    type_long: Final = 0x0000
+    type_short: Final = 0x0400
+    type_string: Final = 0x0C00
+    type_binary: Final = 0x0800
+    type_nullable: Final = 0x1000
+    type_key: Final = 0x2000
+    knownbits: Final = 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: _SequenceType, 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 | None) -> tuple[int, str] | MaybeNone: ...
+        def commit(self, db: _Database) -> None: ...
+
+    _directories: set[str]
+
+    class Directory:
+        db: _Database
+        cab: CAB
+        basedir: Directory | None
+        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: Directory | None,
+            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 | None,
+            cancel: str | None,
+        ) -> 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: ...

package/analyzers/project-map-python/typeshed/stdlib/msilib/schema.pyi

@@ -0,0 +1,95 @@
+import sys
+from typing import Final
+
+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: Final[list[Table]]
+
+    _Validation_records: list[tuple[str, str, str, int | None, int | None, str | None, int | None, str | None, str | None, str]]

package/analyzers/project-map-python/typeshed/stdlib/msilib/sequence.pyi

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

package/analyzers/project-map-python/typeshed/stdlib/msilib/text.pyi

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

package/analyzers/project-map-python/typeshed/stdlib/msvcrt.pyi

@@ -0,0 +1,31 @@
+import sys
+from typing import Final
+
+# This module is only available on Windows
+if sys.platform == "win32":
+    CRT_ASSEMBLY_VERSION: Final[str]
+    LK_UNLCK: Final = 0
+    LK_LOCK: Final = 1
+    LK_NBLCK: Final = 2
+    LK_RLCK: Final = 3
+    LK_NBRLCK: Final = 4
+    SEM_FAILCRITICALERRORS: Final = 0x0001
+    SEM_NOALIGNMENTFAULTEXCEPT: Final = 0x0004
+    SEM_NOGPFAULTERRORBOX: Final = 0x0002
+    SEM_NOOPENFILEERRORBOX: Final = 0x8000
+    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: ...
+    def GetErrorMode() -> int: ...  # undocumented

package/analyzers/project-map-python/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