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

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

@@ -0,0 +1,84 @@
+import sys
+from collections.abc import Container, Iterable, Iterator, Sequence
+from types import CodeType
+from typing import IO, Any
+
+if sys.version_info < (3, 11):
+    LOAD_CONST: int  # undocumented
+    IMPORT_NAME: int  # undocumented
+    STORE_NAME: int  # undocumented
+    STORE_GLOBAL: int  # undocumented
+    STORE_OPS: tuple[int, int]  # undocumented
+    EXTENDED_ARG: 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

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

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