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

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

@@ -0,0 +1,111 @@
+import sys
+from _typeshed import StrPath
+from py_compile import PycInvalidationMode
+from typing import Any, Protocol
+
+__all__ = ["compile_dir", "compile_file", "compile_path"]
+
+class _SupportsSearch(Protocol):
+    def search(self, __string: str) -> Any: ...
+
+if sys.version_info >= (3, 10):
+    def compile_dir(
+        dir: StrPath,
+        maxlevels: int | None = None,
+        ddir: StrPath | None = None,
+        force: bool = False,
+        rx: _SupportsSearch | None = None,
+        quiet: int = 0,
+        legacy: bool = False,
+        optimize: int = -1,
+        workers: int = 1,
+        invalidation_mode: PycInvalidationMode | None = None,
+        *,
+        stripdir: StrPath | None = None,
+        prependdir: StrPath | None = None,
+        limit_sl_dest: StrPath | None = None,
+        hardlink_dupes: bool = False,
+    ) -> int: ...
+    def compile_file(
+        fullname: StrPath,
+        ddir: StrPath | None = None,
+        force: bool = False,
+        rx: _SupportsSearch | None = None,
+        quiet: int = 0,
+        legacy: bool = False,
+        optimize: int = -1,
+        invalidation_mode: PycInvalidationMode | None = None,
+        *,
+        stripdir: StrPath | None = None,
+        prependdir: StrPath | None = None,
+        limit_sl_dest: StrPath | None = None,
+        hardlink_dupes: bool = False,
+    ) -> int: ...
+
+elif sys.version_info >= (3, 9):
+    def compile_dir(
+        dir: StrPath,
+        maxlevels: int | None = None,
+        ddir: StrPath | None = None,
+        force: bool = False,
+        rx: _SupportsSearch | None = None,
+        quiet: int = 0,
+        legacy: bool = False,
+        optimize: int = -1,
+        workers: int = 1,
+        invalidation_mode: PycInvalidationMode | None = None,
+        *,
+        stripdir: str | None = None,  # https://bugs.python.org/issue40447
+        prependdir: StrPath | None = None,
+        limit_sl_dest: StrPath | None = None,
+        hardlink_dupes: bool = False,
+    ) -> int: ...
+    def compile_file(
+        fullname: StrPath,
+        ddir: StrPath | None = None,
+        force: bool = False,
+        rx: _SupportsSearch | None = None,
+        quiet: int = 0,
+        legacy: bool = False,
+        optimize: int = -1,
+        invalidation_mode: PycInvalidationMode | None = None,
+        *,
+        stripdir: str | None = None,  # https://bugs.python.org/issue40447
+        prependdir: StrPath | None = None,
+        limit_sl_dest: StrPath | None = None,
+        hardlink_dupes: bool = False,
+    ) -> int: ...
+
+else:
+    def compile_dir(
+        dir: StrPath,
+        maxlevels: int = 10,
+        ddir: StrPath | None = None,
+        force: bool = False,
+        rx: _SupportsSearch | None = None,
+        quiet: int = 0,
+        legacy: bool = False,
+        optimize: int = -1,
+        workers: int = 1,
+        invalidation_mode: PycInvalidationMode | None = None,
+    ) -> int: ...
+    def compile_file(
+        fullname: StrPath,
+        ddir: StrPath | None = None,
+        force: bool = False,
+        rx: _SupportsSearch | None = None,
+        quiet: int = 0,
+        legacy: bool = False,
+        optimize: int = -1,
+        invalidation_mode: PycInvalidationMode | None = None,
+    ) -> int: ...
+
+def compile_path(
+    skip_curdir: bool = ...,
+    maxlevels: int = 0,
+    force: bool = False,
+    quiet: int = 0,
+    legacy: bool = False,
+    optimize: int = -1,
+    invalidation_mode: PycInvalidationMode | None = None,
+) -> int: ...

jaclang/vendor/mypy/typeshed/stdlib/concurrent/futures/__init__.pyi

@@ -0,0 +1,32 @@
+from ._base import (
+    ALL_COMPLETED as ALL_COMPLETED,
+    FIRST_COMPLETED as FIRST_COMPLETED,
+    FIRST_EXCEPTION as FIRST_EXCEPTION,
+    BrokenExecutor as BrokenExecutor,
+    CancelledError as CancelledError,
+    Executor as Executor,
+    Future as Future,
+    InvalidStateError as InvalidStateError,
+    TimeoutError as TimeoutError,
+    as_completed as as_completed,
+    wait as wait,
+)
+from .process import ProcessPoolExecutor as ProcessPoolExecutor
+from .thread import ThreadPoolExecutor as ThreadPoolExecutor
+
+__all__ = (
+    "FIRST_COMPLETED",
+    "FIRST_EXCEPTION",
+    "ALL_COMPLETED",
+    "CancelledError",
+    "TimeoutError",
+    "BrokenExecutor",
+    "Future",
+    "Executor",
+    "wait",
+    "as_completed",
+    "ProcessPoolExecutor",
+    "ThreadPoolExecutor",
+)
+
+def __dir__() -> tuple[str, ...]: ...

jaclang/vendor/mypy/typeshed/stdlib/concurrent/futures/_base.pyi

@@ -0,0 +1,137 @@
+import sys
+import threading
+from _typeshed import Unused
+from collections.abc import Callable, Iterable, Iterator
+from logging import Logger
+from types import TracebackType
+from typing import Any, Generic, Literal, NamedTuple, Protocol, TypeVar
+from typing_extensions import ParamSpec, Self
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+FIRST_COMPLETED: Literal["FIRST_COMPLETED"]
+FIRST_EXCEPTION: Literal["FIRST_EXCEPTION"]
+ALL_COMPLETED: Literal["ALL_COMPLETED"]
+PENDING: Literal["PENDING"]
+RUNNING: Literal["RUNNING"]
+CANCELLED: Literal["CANCELLED"]
+CANCELLED_AND_NOTIFIED: Literal["CANCELLED_AND_NOTIFIED"]
+FINISHED: Literal["FINISHED"]
+_FUTURE_STATES: list[str]
+_STATE_TO_DESCRIPTION_MAP: dict[str, str]
+LOGGER: Logger
+
+class Error(Exception): ...
+class CancelledError(Error): ...
+
+if sys.version_info >= (3, 11):
+    from builtins import TimeoutError as TimeoutError
+else:
+    class TimeoutError(Error): ...
+
+class InvalidStateError(Error): ...
+class BrokenExecutor(RuntimeError): ...
+
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
+_P = ParamSpec("_P")
+
+class Future(Generic[_T]):
+    _condition: threading.Condition
+    _state: str
+    _result: _T | None
+    _exception: BaseException | None
+    _waiters: list[_Waiter]
+    def cancel(self) -> bool: ...
+    def cancelled(self) -> bool: ...
+    def running(self) -> bool: ...
+    def done(self) -> bool: ...
+    def add_done_callback(self, fn: Callable[[Future[_T]], object]) -> None: ...
+    def result(self, timeout: float | None = None) -> _T: ...
+    def set_running_or_notify_cancel(self) -> bool: ...
+    def set_result(self, result: _T) -> None: ...
+    def exception(self, timeout: float | None = None) -> BaseException | None: ...
+    def set_exception(self, exception: BaseException | None) -> None: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+class Executor:
+    if sys.version_info >= (3, 9):
+        def submit(
+            self, __fn: Callable[_P, _T], *args: _P.args, **kwargs: _P.kwargs
+        ) -> Future[_T]: ...
+    else:
+        def submit(
+            self, fn: Callable[_P, _T], *args: _P.args, **kwargs: _P.kwargs
+        ) -> Future[_T]: ...
+
+    def map(
+        self,
+        fn: Callable[..., _T],
+        *iterables: Iterable[Any],
+        timeout: float | None = None,
+        chunksize: int = 1
+    ) -> Iterator[_T]: ...
+    if sys.version_info >= (3, 9):
+        def shutdown(
+            self, wait: bool = True, *, cancel_futures: bool = False
+        ) -> None: ...
+    else:
+        def shutdown(self, wait: bool = True) -> None: ...
+
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None: ...
+
+class _AsCompletedFuture(Protocol[_T_co]):
+    # as_completed only mutates non-generic aspects of passed Futures and does not do any nominal
+    # checks. Therefore, we can use a Protocol here to allow as_completed to act covariantly.
+    # See the tests for concurrent.futures
+    _condition: threading.Condition
+    _state: str
+    _waiters: list[_Waiter]
+    # Not used by as_completed, but needed to propagate the generic type
+    def result(self, timeout: float | None = None) -> _T_co: ...
+
+def as_completed(
+    fs: Iterable[_AsCompletedFuture[_T]], timeout: float | None = None
+) -> Iterator[Future[_T]]: ...
+
+class DoneAndNotDoneFutures(NamedTuple, Generic[_T]):
+    done: set[Future[_T]]
+    not_done: set[Future[_T]]
+
+def wait(
+    fs: Iterable[Future[_T]],
+    timeout: float | None = None,
+    return_when: str = "ALL_COMPLETED",
+) -> DoneAndNotDoneFutures[_T]: ...
+
+class _Waiter:
+    event: threading.Event
+    finished_futures: list[Future[Any]]
+    def add_result(self, future: Future[Any]) -> None: ...
+    def add_exception(self, future: Future[Any]) -> None: ...
+    def add_cancelled(self, future: Future[Any]) -> None: ...
+
+class _AsCompletedWaiter(_Waiter):
+    lock: threading.Lock
+
+class _FirstCompletedWaiter(_Waiter): ...
+
+class _AllCompletedWaiter(_Waiter):
+    num_pending_calls: int
+    stop_on_exception: bool
+    lock: threading.Lock
+    def __init__(self, num_pending_calls: int, stop_on_exception: bool) -> None: ...
+
+class _AcquireFutures:
+    futures: Iterable[Future[Any]]
+    def __init__(self, futures: Iterable[Future[Any]]) -> None: ...
+    def __enter__(self) -> None: ...
+    def __exit__(self, *args: Unused) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/concurrent/futures/process.pyi

@@ -0,0 +1,272 @@
+import sys
+from collections.abc import (
+    Callable,
+    Generator,
+    Iterable,
+    Mapping,
+    MutableMapping,
+    MutableSequence,
+)
+from multiprocessing.connection import Connection
+from multiprocessing.context import BaseContext, Process
+from multiprocessing.queues import Queue, SimpleQueue
+from threading import Lock, Semaphore, Thread
+from types import TracebackType
+from typing import Any, Generic, TypeVar, overload
+from typing_extensions import TypeVarTuple, Unpack
+from weakref import ref
+
+from ._base import BrokenExecutor, Executor, Future
+
+_T = TypeVar("_T")
+_Ts = TypeVarTuple("_Ts")
+
+_threads_wakeups: MutableMapping[Any, Any]
+_global_shutdown: bool
+
+class _ThreadWakeup:
+    _closed: bool
+    _reader: Connection
+    _writer: Connection
+    def close(self) -> None: ...
+    def wakeup(self) -> None: ...
+    def clear(self) -> None: ...
+
+def _python_exit() -> None: ...
+
+EXTRA_QUEUED_CALLS: int
+
+_MAX_WINDOWS_WORKERS: int
+
+class _RemoteTraceback(Exception):
+    tb: str
+    def __init__(self, tb: TracebackType) -> None: ...
+
+class _ExceptionWithTraceback:
+    exc: BaseException
+    tb: TracebackType
+    def __init__(self, exc: BaseException, tb: TracebackType) -> None: ...
+    def __reduce__(self) -> str | tuple[Any, ...]: ...
+
+def _rebuild_exc(exc: Exception, tb: str) -> Exception: ...
+
+class _WorkItem(Generic[_T]):
+    future: Future[_T]
+    fn: Callable[..., _T]
+    args: Iterable[Any]
+    kwargs: Mapping[str, Any]
+    def __init__(
+        self,
+        future: Future[_T],
+        fn: Callable[..., _T],
+        args: Iterable[Any],
+        kwargs: Mapping[str, Any],
+    ) -> None: ...
+
+class _ResultItem:
+    work_id: int
+    exception: Exception
+    result: Any
+    if sys.version_info >= (3, 11):
+        exit_pid: int | None
+        def __init__(
+            self,
+            work_id: int,
+            exception: Exception | None = None,
+            result: Any | None = None,
+            exit_pid: int | None = None,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            work_id: int,
+            exception: Exception | None = None,
+            result: Any | None = None,
+        ) -> None: ...
+
+class _CallItem:
+    work_id: int
+    fn: Callable[..., Any]
+    args: Iterable[Any]
+    kwargs: Mapping[str, Any]
+    def __init__(
+        self,
+        work_id: int,
+        fn: Callable[..., Any],
+        args: Iterable[Any],
+        kwargs: Mapping[str, Any],
+    ) -> None: ...
+
+class _SafeQueue(Queue[Future[Any]]):
+    pending_work_items: dict[int, _WorkItem[Any]]
+    shutdown_lock: Lock
+    thread_wakeup: _ThreadWakeup
+    if sys.version_info >= (3, 9):
+        def __init__(
+            self,
+            max_size: int | None = 0,
+            *,
+            ctx: BaseContext,
+            pending_work_items: dict[int, _WorkItem[Any]],
+            shutdown_lock: Lock,
+            thread_wakeup: _ThreadWakeup,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            max_size: int | None = 0,
+            *,
+            ctx: BaseContext,
+            pending_work_items: dict[int, _WorkItem[Any]],
+        ) -> None: ...
+
+    def _on_queue_feeder_error(self, e: Exception, obj: _CallItem) -> None: ...
+
+def _get_chunks(
+    *iterables: Any, chunksize: int
+) -> Generator[tuple[Any, ...], None, None]: ...
+def _process_chunk(
+    fn: Callable[..., _T], chunk: Iterable[tuple[Any, ...]]
+) -> list[_T]: ...
+
+if sys.version_info >= (3, 11):
+    def _sendback_result(
+        result_queue: SimpleQueue[_WorkItem[Any]],
+        work_id: int,
+        result: Any | None = None,
+        exception: Exception | None = None,
+        exit_pid: int | None = None,
+    ) -> None: ...
+
+else:
+    def _sendback_result(
+        result_queue: SimpleQueue[_WorkItem[Any]],
+        work_id: int,
+        result: Any | None = None,
+        exception: Exception | None = None,
+    ) -> None: ...
+
+if sys.version_info >= (3, 11):
+    def _process_worker(
+        call_queue: Queue[_CallItem],
+        result_queue: SimpleQueue[_ResultItem],
+        initializer: Callable[[Unpack[_Ts]], object] | None,
+        initargs: tuple[Unpack[_Ts]],
+        max_tasks: int | None = None,
+    ) -> None: ...
+
+else:
+    def _process_worker(
+        call_queue: Queue[_CallItem],
+        result_queue: SimpleQueue[_ResultItem],
+        initializer: Callable[[Unpack[_Ts]], object] | None,
+        initargs: tuple[Unpack[_Ts]],
+    ) -> None: ...
+
+if sys.version_info >= (3, 9):
+    class _ExecutorManagerThread(Thread):
+        thread_wakeup: _ThreadWakeup
+        shutdown_lock: Lock
+        executor_reference: ref[Any]
+        processes: MutableMapping[int, Process]
+        call_queue: Queue[_CallItem]
+        result_queue: SimpleQueue[_ResultItem]
+        work_ids_queue: Queue[int]
+        pending_work_items: dict[int, _WorkItem[Any]]
+        def __init__(self, executor: ProcessPoolExecutor) -> None: ...
+        def run(self) -> None: ...
+        def add_call_item_to_queue(self) -> None: ...
+        def wait_result_broken_or_wakeup(self) -> tuple[Any, bool, str]: ...
+        def process_result_item(self, result_item: int | _ResultItem) -> None: ...
+        def is_shutting_down(self) -> bool: ...
+        def terminate_broken(self, cause: str) -> None: ...
+        def flag_executor_shutting_down(self) -> None: ...
+        def shutdown_workers(self) -> None: ...
+        def join_executor_internals(self) -> None: ...
+        def get_n_children_alive(self) -> int: ...
+
+_system_limits_checked: bool
+_system_limited: bool | None
+
+def _check_system_limits() -> None: ...
+def _chain_from_iterable_of_lists(iterable: Iterable[MutableSequence[Any]]) -> Any: ...
+
+class BrokenProcessPool(BrokenExecutor): ...
+
+class ProcessPoolExecutor(Executor):
+    _mp_context: BaseContext | None
+    _initializer: Callable[..., None] | None
+    _initargs: tuple[Any, ...]
+    _executor_manager_thread: _ThreadWakeup
+    _processes: MutableMapping[int, Process]
+    _shutdown_thread: bool
+    _shutdown_lock: Lock
+    _idle_worker_semaphore: Semaphore
+    _broken: bool
+    _queue_count: int
+    _pending_work_items: dict[int, _WorkItem[Any]]
+    _cancel_pending_futures: bool
+    _executor_manager_thread_wakeup: _ThreadWakeup
+    _result_queue: SimpleQueue[Any]
+    _work_ids: Queue[Any]
+    if sys.version_info >= (3, 11):
+        @overload
+        def __init__(
+            self,
+            max_workers: int | None = None,
+            mp_context: BaseContext | None = None,
+            initializer: Callable[[], object] | None = None,
+            initargs: tuple[()] = (),
+            *,
+            max_tasks_per_child: int | None = None,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            max_workers: int | None = None,
+            mp_context: BaseContext | None = None,
+            *,
+            initializer: Callable[[Unpack[_Ts]], object],
+            initargs: tuple[Unpack[_Ts]],
+            max_tasks_per_child: int | None = None,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            max_workers: int | None,
+            mp_context: BaseContext | None,
+            initializer: Callable[[Unpack[_Ts]], object],
+            initargs: tuple[Unpack[_Ts]],
+            *,
+            max_tasks_per_child: int | None = None,
+        ) -> None: ...
+    else:
+        @overload
+        def __init__(
+            self,
+            max_workers: int | None = None,
+            mp_context: BaseContext | None = None,
+            initializer: Callable[[], object] | None = None,
+            initargs: tuple[()] = (),
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            max_workers: int | None = None,
+            mp_context: BaseContext | None = None,
+            *,
+            initializer: Callable[[Unpack[_Ts]], object],
+            initargs: tuple[Unpack[_Ts]],
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            max_workers: int | None,
+            mp_context: BaseContext | None,
+            initializer: Callable[[Unpack[_Ts]], object],
+            initargs: tuple[Unpack[_Ts]],
+        ) -> None: ...
+    if sys.version_info >= (3, 9):
+        def _start_executor_manager_thread(self) -> None: ...
+
+    def _adjust_process_count(self) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/concurrent/futures/thread.pyi

@@ -0,0 +1,86 @@
+import queue
+import sys
+from collections.abc import Callable, Iterable, Mapping, Set as AbstractSet
+from threading import Lock, Semaphore, Thread
+from typing import Any, Generic, TypeVar, overload
+from typing_extensions import TypeVarTuple, Unpack
+from weakref import ref
+
+from ._base import BrokenExecutor, Executor, Future
+
+_Ts = TypeVarTuple("_Ts")
+
+_threads_queues: Mapping[Any, Any]
+_shutdown: bool
+_global_shutdown_lock: Lock
+
+def _python_exit() -> None: ...
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+_S = TypeVar("_S")
+
+class _WorkItem(Generic[_S]):
+    future: Future[_S]
+    fn: Callable[..., _S]
+    args: Iterable[Any]
+    kwargs: Mapping[str, Any]
+    def __init__(
+        self,
+        future: Future[_S],
+        fn: Callable[..., _S],
+        args: Iterable[Any],
+        kwargs: Mapping[str, Any],
+    ) -> None: ...
+    def run(self) -> None: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+def _worker(
+    executor_reference: ref[Any],
+    work_queue: queue.SimpleQueue[Any],
+    initializer: Callable[[Unpack[_Ts]], object],
+    initargs: tuple[Unpack[_Ts]],
+) -> None: ...
+
+class BrokenThreadPool(BrokenExecutor): ...
+
+class ThreadPoolExecutor(Executor):
+    _max_workers: int
+    _idle_semaphore: Semaphore
+    _threads: AbstractSet[Thread]
+    _broken: bool
+    _shutdown: bool
+    _shutdown_lock: Lock
+    _thread_name_prefix: str | None
+    _initializer: Callable[..., None] | None
+    _initargs: tuple[Any, ...]
+    _work_queue: queue.SimpleQueue[_WorkItem[Any]]
+    @overload
+    def __init__(
+        self,
+        max_workers: int | None = None,
+        thread_name_prefix: str = "",
+        initializer: Callable[[], object] | None = None,
+        initargs: tuple[()] = (),
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        max_workers: int | None = None,
+        thread_name_prefix: str = "",
+        *,
+        initializer: Callable[[Unpack[_Ts]], object],
+        initargs: tuple[Unpack[_Ts]],
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        max_workers: int | None,
+        thread_name_prefix: str,
+        initializer: Callable[[Unpack[_Ts]], object],
+        initargs: tuple[Unpack[_Ts]],
+    ) -> None: ...
+    def _adjust_thread_count(self) -> None: ...
+    def _initializer_failed(self) -> None: ...