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

jaclang/vendor/mypy/typeshed/stdlib/asyncio/format_helpers.pyi

@@ -0,0 +1,26 @@
+import functools
+import traceback
+from collections.abc import Iterable
+from types import FrameType, FunctionType
+from typing import Any, overload
+from typing_extensions import TypeAlias
+
+class _HasWrapper:
+    __wrapper__: _HasWrapper | FunctionType
+
+_FuncType: TypeAlias = (
+    FunctionType | _HasWrapper | functools.partial[Any] | functools.partialmethod[Any]
+)
+
+@overload
+def _get_function_source(func: _FuncType) -> tuple[str, int]: ...
+@overload
+def _get_function_source(func: object) -> tuple[str, int] | None: ...
+def _format_callback_source(func: object, args: Iterable[Any]) -> str: ...
+def _format_args_and_kwargs(args: Iterable[Any], kwargs: dict[str, Any]) -> str: ...
+def _format_callback(
+    func: object, args: Iterable[Any], kwargs: dict[str, Any], suffix: str = ""
+) -> str: ...
+def extract_stack(
+    f: FrameType | None = None, limit: int | None = None
+) -> traceback.StackSummary: ...

jaclang/vendor/mypy/typeshed/stdlib/asyncio/futures.pyi

@@ -0,0 +1,61 @@
+import sys
+from collections.abc import Awaitable, Callable, Generator, Iterable
+from concurrent.futures._base import Future as _ConcurrentFuture
+from contextvars import Context
+from typing import Any, Literal, TypeVar
+from typing_extensions import Self, TypeGuard
+
+from .events import AbstractEventLoop
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+__all__ = ("Future", "wrap_future", "isfuture")
+
+_T = TypeVar("_T")
+
+# asyncio defines 'isfuture()' in base_futures.py and re-imports it in futures.py
+# but it leads to circular import error in pytype tool.
+# That's why the import order is reversed.
+def isfuture(obj: object) -> TypeGuard[Future[Any]]: ...
+
+class Future(Awaitable[_T], Iterable[_T]):
+    _state: str
+    @property
+    def _exception(self) -> BaseException | None: ...
+    _blocking: bool
+    @property
+    def _log_traceback(self) -> bool: ...
+    @_log_traceback.setter
+    def _log_traceback(self, val: Literal[False]) -> None: ...
+    _asyncio_future_blocking: bool  # is a part of duck-typing contract for `Future`
+    def __init__(self, *, loop: AbstractEventLoop | None = ...) -> None: ...
+    def __del__(self) -> None: ...
+    def get_loop(self) -> AbstractEventLoop: ...
+    @property
+    def _callbacks(self) -> list[tuple[Callable[[Self], Any], Context]]: ...
+    def add_done_callback(
+        self, __fn: Callable[[Self], object], *, context: Context | None = None
+    ) -> None: ...
+    if sys.version_info >= (3, 9):
+        def cancel(self, msg: Any | None = None) -> bool: ...
+    else:
+        def cancel(self) -> bool: ...
+
+    def cancelled(self) -> bool: ...
+    def done(self) -> bool: ...
+    def result(self) -> _T: ...
+    def exception(self) -> BaseException | None: ...
+    def remove_done_callback(self, __fn: Callable[[Self], object]) -> int: ...
+    def set_result(self, __result: _T) -> None: ...
+    def set_exception(self, __exception: type | BaseException) -> None: ...
+    def __iter__(self) -> Generator[Any, None, _T]: ...
+    def __await__(self) -> Generator[Any, None, _T]: ...
+    @property
+    def _loop(self) -> AbstractEventLoop: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+def wrap_future(
+    future: _ConcurrentFuture[_T] | Future[_T], *, loop: AbstractEventLoop | None = None
+) -> Future[_T]: ...

jaclang/vendor/mypy/typeshed/stdlib/asyncio/locks.pyi

@@ -0,0 +1,131 @@
+import enum
+import sys
+from _typeshed import Unused
+from collections import deque
+from collections.abc import Callable, Generator
+from types import TracebackType
+from typing import Any, Literal, TypeVar
+from typing_extensions import Self
+
+from .events import AbstractEventLoop
+from .futures import Future
+
+if sys.version_info >= (3, 10):
+    from .mixins import _LoopBoundMixin
+else:
+    _LoopBoundMixin = object
+
+if sys.version_info >= (3, 11):
+    __all__ = ("Lock", "Event", "Condition", "Semaphore", "BoundedSemaphore", "Barrier")
+else:
+    __all__ = ("Lock", "Event", "Condition", "Semaphore", "BoundedSemaphore")
+
+_T = TypeVar("_T")
+
+if sys.version_info >= (3, 9):
+    class _ContextManagerMixin:
+        async def __aenter__(self) -> None: ...
+        async def __aexit__(
+            self,
+            exc_type: type[BaseException] | None,
+            exc: BaseException | None,
+            tb: TracebackType | None,
+        ) -> None: ...
+
+else:
+    class _ContextManager:
+        def __init__(self, lock: Lock | Semaphore) -> None: ...
+        def __enter__(self) -> None: ...
+        def __exit__(self, *args: Unused) -> None: ...
+
+    class _ContextManagerMixin:
+        # Apparently this exists to *prohibit* use as a context manager.
+        # def __enter__(self) -> NoReturn: ... see: https://github.com/python/typing/issues/1043
+        # def __exit__(self, *args: Any) -> None: ...
+        def __iter__(self) -> Generator[Any, None, _ContextManager]: ...
+        def __await__(self) -> Generator[Any, None, _ContextManager]: ...
+        async def __aenter__(self) -> None: ...
+        async def __aexit__(
+            self,
+            exc_type: type[BaseException] | None,
+            exc: BaseException | None,
+            tb: TracebackType | None,
+        ) -> None: ...
+
+class Lock(_ContextManagerMixin, _LoopBoundMixin):
+    _waiters: deque[Future[Any]] | None
+    if sys.version_info >= (3, 10):
+        def __init__(self) -> None: ...
+    else:
+        def __init__(self, *, loop: AbstractEventLoop | None = None) -> None: ...
+
+    def locked(self) -> bool: ...
+    async def acquire(self) -> Literal[True]: ...
+    def release(self) -> None: ...
+
+class Event(_LoopBoundMixin):
+    _waiters: deque[Future[Any]]
+    if sys.version_info >= (3, 10):
+        def __init__(self) -> None: ...
+    else:
+        def __init__(self, *, loop: AbstractEventLoop | None = None) -> None: ...
+
+    def is_set(self) -> bool: ...
+    def set(self) -> None: ...
+    def clear(self) -> None: ...
+    async def wait(self) -> Literal[True]: ...
+
+class Condition(_ContextManagerMixin, _LoopBoundMixin):
+    _waiters: deque[Future[Any]]
+    if sys.version_info >= (3, 10):
+        def __init__(self, lock: Lock | None = None) -> None: ...
+    else:
+        def __init__(
+            self, lock: Lock | None = None, *, loop: AbstractEventLoop | None = None
+        ) -> None: ...
+
+    def locked(self) -> bool: ...
+    async def acquire(self) -> Literal[True]: ...
+    def release(self) -> None: ...
+    async def wait(self) -> Literal[True]: ...
+    async def wait_for(self, predicate: Callable[[], _T]) -> _T: ...
+    def notify(self, n: int = 1) -> None: ...
+    def notify_all(self) -> None: ...
+
+class Semaphore(_ContextManagerMixin, _LoopBoundMixin):
+    _value: int
+    _waiters: deque[Future[Any]] | None
+    if sys.version_info >= (3, 10):
+        def __init__(self, value: int = 1) -> None: ...
+    else:
+        def __init__(
+            self, value: int = 1, *, loop: AbstractEventLoop | None = None
+        ) -> None: ...
+
+    def locked(self) -> bool: ...
+    async def acquire(self) -> Literal[True]: ...
+    def release(self) -> None: ...
+    def _wake_up_next(self) -> None: ...
+
+class BoundedSemaphore(Semaphore): ...
+
+if sys.version_info >= (3, 11):
+    class _BarrierState(enum.Enum):  # undocumented
+        FILLING: str
+        DRAINING: str
+        RESETTING: str
+        BROKEN: str
+
+    class Barrier(_LoopBoundMixin):
+        def __init__(self, parties: int) -> None: ...
+        async def __aenter__(self) -> Self: ...
+        async def __aexit__(self, *args: Unused) -> None: ...
+        async def wait(self) -> int: ...
+        async def abort(self) -> None: ...
+        async def reset(self) -> None: ...
+        @property
+        def parties(self) -> int: ...
+        @property
+        def n_waiting(self) -> int: ...
+        @property
+        def broken(self) -> bool: ...

jaclang/vendor/mypy/typeshed/stdlib/asyncio/log.pyi

@@ -0,0 +1,3 @@
+import logging
+
+logger: logging.Logger

jaclang/vendor/mypy/typeshed/stdlib/asyncio/mixins.pyi

@@ -0,0 +1,9 @@
+import sys
+import threading
+from typing_extensions import Never
+
+_global_lock: threading.Lock
+
+class _LoopBoundMixin:
+    if sys.version_info < (3, 11):
+        def __init__(self, *, loop: Never = ...) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/asyncio/proactor_events.pyi

@@ -0,0 +1,72 @@
+import sys
+from collections.abc import Mapping
+from socket import socket
+from typing import Any, ClassVar, Literal
+
+from . import base_events, constants, events, futures, streams, transports
+
+__all__ = ("BaseProactorEventLoop",)
+
+class _ProactorBasePipeTransport(
+    transports._FlowControlMixin, transports.BaseTransport
+):
+    def __init__(
+        self,
+        loop: events.AbstractEventLoop,
+        sock: socket,
+        protocol: streams.StreamReaderProtocol,
+        waiter: futures.Future[Any] | None = None,
+        extra: Mapping[Any, Any] | None = None,
+        server: events.AbstractServer | None = None,
+    ) -> None: ...
+    def __del__(self) -> None: ...
+
+class _ProactorReadPipeTransport(_ProactorBasePipeTransport, transports.ReadTransport):
+    if sys.version_info >= (3, 10):
+        def __init__(
+            self,
+            loop: events.AbstractEventLoop,
+            sock: socket,
+            protocol: streams.StreamReaderProtocol,
+            waiter: futures.Future[Any] | None = None,
+            extra: Mapping[Any, Any] | None = None,
+            server: events.AbstractServer | None = None,
+            buffer_size: int = 65536,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            loop: events.AbstractEventLoop,
+            sock: socket,
+            protocol: streams.StreamReaderProtocol,
+            waiter: futures.Future[Any] | None = None,
+            extra: Mapping[Any, Any] | None = None,
+            server: events.AbstractServer | None = None,
+        ) -> None: ...
+
+class _ProactorBaseWritePipeTransport(
+    _ProactorBasePipeTransport, transports.WriteTransport
+): ...
+class _ProactorWritePipeTransport(_ProactorBaseWritePipeTransport): ...
+class _ProactorDuplexPipeTransport(
+    _ProactorReadPipeTransport, _ProactorBaseWritePipeTransport, transports.Transport
+): ...
+
+class _ProactorSocketTransport(
+    _ProactorReadPipeTransport, _ProactorBaseWritePipeTransport, transports.Transport
+):
+    _sendfile_compatible: ClassVar[constants._SendfileMode]
+    def __init__(
+        self,
+        loop: events.AbstractEventLoop,
+        sock: socket,
+        protocol: streams.StreamReaderProtocol,
+        waiter: futures.Future[Any] | None = None,
+        extra: Mapping[Any, Any] | None = None,
+        server: events.AbstractServer | None = None,
+    ) -> None: ...
+    def _set_extra(self, sock: socket) -> None: ...
+    def can_write_eof(self) -> Literal[True]: ...
+
+class BaseProactorEventLoop(base_events.BaseEventLoop):
+    def __init__(self, proactor: Any) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/asyncio/protocols.pyi

@@ -0,0 +1,40 @@
+from _typeshed import ReadableBuffer
+from asyncio import transports
+from typing import Any
+
+__all__ = (
+    "BaseProtocol",
+    "Protocol",
+    "DatagramProtocol",
+    "SubprocessProtocol",
+    "BufferedProtocol",
+)
+
+class BaseProtocol:
+    def connection_made(self, transport: transports.BaseTransport) -> None: ...
+    def connection_lost(self, exc: Exception | None) -> None: ...
+    def pause_writing(self) -> None: ...
+    def resume_writing(self) -> None: ...
+
+class Protocol(BaseProtocol):
+    def data_received(self, data: bytes) -> None: ...
+    def eof_received(self) -> bool | None: ...
+
+class BufferedProtocol(BaseProtocol):
+    def get_buffer(self, sizehint: int) -> ReadableBuffer: ...
+    def buffer_updated(self, nbytes: int) -> None: ...
+    def eof_received(self) -> bool | None: ...
+
+class DatagramProtocol(BaseProtocol):
+    def connection_made(self, transport: transports.DatagramTransport) -> None: ...  # type: ignore[override]
+    # addr can be a tuple[int, int] for some unusual protocols like socket.AF_NETLINK.
+    # Use tuple[str | Any, int] to not cause typechecking issues on most usual cases.
+    # This could be improved by using tuple[AnyOf[str, int], int] if the AnyOf feature is accepted.
+    # See https://github.com/python/typing/issues/566
+    def datagram_received(self, data: bytes, addr: tuple[str | Any, int]) -> None: ...
+    def error_received(self, exc: Exception) -> None: ...
+
+class SubprocessProtocol(BaseProtocol):
+    def pipe_data_received(self, fd: int, data: bytes) -> None: ...
+    def pipe_connection_lost(self, fd: int, exc: Exception | None) -> None: ...
+    def process_exited(self) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/asyncio/queues.pyi

@@ -0,0 +1,49 @@
+import sys
+from asyncio.events import AbstractEventLoop
+from typing import Any, Generic, TypeVar
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+if sys.version_info >= (3, 10):
+    from .mixins import _LoopBoundMixin
+else:
+    _LoopBoundMixin = object
+
+__all__ = ("Queue", "PriorityQueue", "LifoQueue", "QueueFull", "QueueEmpty")
+
+class QueueEmpty(Exception): ...
+class QueueFull(Exception): ...
+
+_T = TypeVar("_T")
+
+# If Generic[_T] is last and _LoopBoundMixin is object, pyright is unhappy.
+# We can remove the noqa pragma when dropping 3.9 support.
+class Queue(Generic[_T], _LoopBoundMixin):  # noqa: Y059
+    if sys.version_info >= (3, 10):
+        def __init__(self, maxsize: int = 0) -> None: ...
+    else:
+        def __init__(
+            self, maxsize: int = 0, *, loop: AbstractEventLoop | None = None
+        ) -> None: ...
+
+    def _init(self, maxsize: int) -> None: ...
+    def _get(self) -> _T: ...
+    def _put(self, item: _T) -> None: ...
+    def _format(self) -> str: ...
+    def qsize(self) -> int: ...
+    @property
+    def maxsize(self) -> int: ...
+    def empty(self) -> bool: ...
+    def full(self) -> bool: ...
+    async def put(self, item: _T) -> None: ...
+    def put_nowait(self, item: _T) -> None: ...
+    async def get(self) -> _T: ...
+    def get_nowait(self) -> _T: ...
+    async def join(self) -> None: ...
+    def task_done(self) -> None: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, type: Any) -> GenericAlias: ...
+
+class PriorityQueue(Queue[_T]): ...
+class LifoQueue(Queue[_T]): ...

jaclang/vendor/mypy/typeshed/stdlib/asyncio/runners.pyi

@@ -0,0 +1,44 @@
+import sys
+from _typeshed import Unused
+from collections.abc import Callable, Coroutine
+from contextvars import Context
+from typing import Any, TypeVar, final
+from typing_extensions import Self
+
+from .events import AbstractEventLoop
+
+if sys.version_info >= (3, 11):
+    __all__ = ("Runner", "run")
+else:
+    __all__ = ("run",)
+_T = TypeVar("_T")
+
+if sys.version_info >= (3, 11):
+    @final
+    class Runner:
+        def __init__(
+            self,
+            *,
+            debug: bool | None = None,
+            loop_factory: Callable[[], AbstractEventLoop] | None = None
+        ) -> None: ...
+        def __enter__(self) -> Self: ...
+        def __exit__(
+            self, exc_type: Unused, exc_val: Unused, exc_tb: Unused
+        ) -> None: ...
+        def close(self) -> None: ...
+        def get_loop(self) -> AbstractEventLoop: ...
+        def run(
+            self, coro: Coroutine[Any, Any, _T], *, context: Context | None = None
+        ) -> _T: ...
+
+if sys.version_info >= (3, 12):
+    def run(
+        main: Coroutine[Any, Any, _T],
+        *,
+        debug: bool | None = ...,
+        loop_factory: Callable[[], AbstractEventLoop] | None = ...
+    ) -> _T: ...
+
+else:
+    def run(main: Coroutine[Any, Any, _T], *, debug: bool | None = None) -> _T: ...

jaclang/vendor/mypy/typeshed/stdlib/asyncio/selector_events.pyi

@@ -0,0 +1,8 @@
+import selectors
+
+from . import base_events
+
+__all__ = ("BaseSelectorEventLoop",)
+
+class BaseSelectorEventLoop(base_events.BaseEventLoop):
+    def __init__(self, selector: selectors.BaseSelector | None = None) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/asyncio/sslproto.pyi

@@ -0,0 +1,189 @@
+import ssl
+import sys
+from collections import deque
+from collections.abc import Callable
+from enum import Enum
+from typing import Any, ClassVar, Literal
+from typing_extensions import TypeAlias
+
+from . import constants, events, futures, protocols, transports
+
+def _create_transport_context(
+    server_side: bool, server_hostname: str | None
+) -> ssl.SSLContext: ...
+
+if sys.version_info >= (3, 11):
+    SSLAgainErrors: tuple[type[ssl.SSLWantReadError], type[ssl.SSLSyscallError]]
+
+    class SSLProtocolState(Enum):
+        UNWRAPPED: str
+        DO_HANDSHAKE: str
+        WRAPPED: str
+        FLUSHING: str
+        SHUTDOWN: str
+
+    class AppProtocolState(Enum):
+        STATE_INIT: str
+        STATE_CON_MADE: str
+        STATE_EOF: str
+        STATE_CON_LOST: str
+
+    def add_flowcontrol_defaults(
+        high: int | None, low: int | None, kb: int
+    ) -> tuple[int, int]: ...
+
+else:
+    _UNWRAPPED: Literal["UNWRAPPED"]
+    _DO_HANDSHAKE: Literal["DO_HANDSHAKE"]
+    _WRAPPED: Literal["WRAPPED"]
+    _SHUTDOWN: Literal["SHUTDOWN"]
+
+if sys.version_info < (3, 11):
+    class _SSLPipe:
+        max_size: ClassVar[int]
+
+        _context: ssl.SSLContext
+        _server_side: bool
+        _server_hostname: str | None
+        _state: str
+        _incoming: ssl.MemoryBIO
+        _outgoing: ssl.MemoryBIO
+        _sslobj: ssl.SSLObject | None
+        _need_ssldata: bool
+        _handshake_cb: Callable[[BaseException | None], None] | None
+        _shutdown_cb: Callable[[], None] | None
+        def __init__(
+            self,
+            context: ssl.SSLContext,
+            server_side: bool,
+            server_hostname: str | None = None,
+        ) -> None: ...
+        @property
+        def context(self) -> ssl.SSLContext: ...
+        @property
+        def ssl_object(self) -> ssl.SSLObject | None: ...
+        @property
+        def need_ssldata(self) -> bool: ...
+        @property
+        def wrapped(self) -> bool: ...
+        def do_handshake(
+            self, callback: Callable[[BaseException | None], object] | None = None
+        ) -> list[bytes]: ...
+        def shutdown(
+            self, callback: Callable[[], object] | None = None
+        ) -> list[bytes]: ...
+        def feed_eof(self) -> None: ...
+        def feed_ssldata(
+            self, data: bytes, only_handshake: bool = False
+        ) -> tuple[list[bytes], list[bytes]]: ...
+        def feed_appdata(
+            self, data: bytes, offset: int = 0
+        ) -> tuple[list[bytes], int]: ...
+
+class _SSLProtocolTransport(transports._FlowControlMixin, transports.Transport):
+    _sendfile_compatible: ClassVar[constants._SendfileMode]
+
+    _loop: events.AbstractEventLoop
+    if sys.version_info >= (3, 11):
+        _ssl_protocol: SSLProtocol | None
+    else:
+        _ssl_protocol: SSLProtocol
+    _closed: bool
+    def __init__(
+        self, loop: events.AbstractEventLoop, ssl_protocol: SSLProtocol
+    ) -> None: ...
+    def get_extra_info(
+        self, name: str, default: Any | None = None
+    ) -> dict[str, Any]: ...
+    @property
+    def _protocol_paused(self) -> bool: ...
+    def write(self, data: bytes | bytearray | memoryview) -> None: ...
+    def can_write_eof(self) -> Literal[False]: ...
+    if sys.version_info >= (3, 11):
+        def get_write_buffer_limits(self) -> tuple[int, int]: ...
+        def get_read_buffer_limits(self) -> tuple[int, int]: ...
+        def set_read_buffer_limits(
+            self, high: int | None = None, low: int | None = None
+        ) -> None: ...
+        def get_read_buffer_size(self) -> int: ...
+
+    def __del__(self) -> None: ...
+
+if sys.version_info >= (3, 11):
+    _SSLProtocolBase: TypeAlias = protocols.BufferedProtocol
+else:
+    _SSLProtocolBase: TypeAlias = protocols.Protocol
+
+class SSLProtocol(_SSLProtocolBase):
+    _server_side: bool
+    _server_hostname: str | None
+    _sslcontext: ssl.SSLContext
+    _extra: dict[str, Any]
+    _write_backlog: deque[tuple[bytes, int]]
+    _write_buffer_size: int
+    _waiter: futures.Future[Any]
+    _loop: events.AbstractEventLoop
+    _app_transport: _SSLProtocolTransport
+    _transport: transports.BaseTransport | None
+    _ssl_handshake_timeout: int | None
+    _app_protocol: protocols.BaseProtocol
+    _app_protocol_is_buffer: bool
+
+    if sys.version_info >= (3, 11):
+        max_size: ClassVar[int]
+    else:
+        _sslpipe: _SSLPipe | None
+        _session_established: bool
+        _call_connection_made: bool
+        _in_handshake: bool
+        _in_shutdown: bool
+
+    if sys.version_info >= (3, 11):
+        def __init__(
+            self,
+            loop: events.AbstractEventLoop,
+            app_protocol: protocols.BaseProtocol,
+            sslcontext: ssl.SSLContext,
+            waiter: futures.Future[Any],
+            server_side: bool = False,
+            server_hostname: str | None = None,
+            call_connection_made: bool = True,
+            ssl_handshake_timeout: int | None = None,
+            ssl_shutdown_timeout: float | None = None,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            loop: events.AbstractEventLoop,
+            app_protocol: protocols.BaseProtocol,
+            sslcontext: ssl.SSLContext,
+            waiter: futures.Future[Any],
+            server_side: bool = False,
+            server_hostname: str | None = None,
+            call_connection_made: bool = True,
+            ssl_handshake_timeout: int | None = None,
+        ) -> None: ...
+
+    def _set_app_protocol(self, app_protocol: protocols.BaseProtocol) -> None: ...
+    def _wakeup_waiter(self, exc: BaseException | None = None) -> None: ...
+    def connection_lost(self, exc: BaseException | None) -> None: ...
+    def eof_received(self) -> None: ...
+    def _get_extra_info(self, name: str, default: Any | None = None) -> Any: ...
+    def _start_shutdown(self) -> None: ...
+    if sys.version_info >= (3, 11):
+        def _write_appdata(self, list_of_data: list[bytes]) -> None: ...
+    else:
+        def _write_appdata(self, data: bytes) -> None: ...
+
+    def _start_handshake(self) -> None: ...
+    def _check_handshake_timeout(self) -> None: ...
+    def _on_handshake_complete(self, handshake_exc: BaseException | None) -> None: ...
+    def _fatal_error(
+        self, exc: BaseException, message: str = "Fatal error on transport"
+    ) -> None: ...
+    def _abort(self) -> None: ...
+    if sys.version_info >= (3, 11):
+        def get_buffer(self, n: int) -> memoryview: ...
+    else:
+        def _finalize(self) -> None: ...
+        def _process_write_backlog(self) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/asyncio/staggered.pyi

@@ -0,0 +1,13 @@
+from collections.abc import Awaitable, Callable, Iterable
+from typing import Any
+
+from . import events
+
+__all__ = ("staggered_race",)
+
+async def staggered_race(
+    coro_fns: Iterable[Callable[[], Awaitable[Any]]],
+    delay: float | None,
+    *,
+    loop: events.AbstractEventLoop | None = None
+) -> tuple[Any, int | None, list[Exception | None]]: ...