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

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

@@ -0,0 +1,140 @@
+import socket
+import sys
+from _typeshed import ReadableBuffer
+from builtins import (
+    type as Type,
+)  # alias to avoid name clashes with property named "type"
+from collections.abc import Iterable
+from types import TracebackType
+from typing import Any, BinaryIO, NoReturn, overload
+from typing_extensions import TypeAlias
+
+# These are based in socket, maybe move them out into _typeshed.pyi or such
+_Address: TypeAlias = socket._Address
+_RetAddress: TypeAlias = Any
+_WriteBuffer: TypeAlias = bytearray | memoryview
+_CMSG: TypeAlias = tuple[int, int, bytes]
+
+class TransportSocket:
+    def __init__(self, sock: socket.socket) -> None: ...
+    @property
+    def family(self) -> int: ...
+    @property
+    def type(self) -> int: ...
+    @property
+    def proto(self) -> int: ...
+    def __getstate__(self) -> NoReturn: ...
+    def fileno(self) -> int: ...
+    def dup(self) -> socket.socket: ...
+    def get_inheritable(self) -> bool: ...
+    def shutdown(self, how: int) -> None: ...
+    @overload
+    def getsockopt(self, level: int, optname: int) -> int: ...
+    @overload
+    def getsockopt(self, level: int, optname: int, buflen: int) -> bytes: ...
+    @overload
+    def setsockopt(
+        self, level: int, optname: int, value: int | ReadableBuffer
+    ) -> None: ...
+    @overload
+    def setsockopt(
+        self, level: int, optname: int, value: None, optlen: int
+    ) -> None: ...
+    def getpeername(self) -> _RetAddress: ...
+    def getsockname(self) -> _RetAddress: ...
+    def getsockbyname(
+        self,
+    ) -> NoReturn: ...  # This method doesn't exist on socket, yet is passed through?
+    def settimeout(self, value: float | None) -> None: ...
+    def gettimeout(self) -> float | None: ...
+    def setblocking(self, flag: bool) -> None: ...
+    if sys.version_info < (3, 11):
+        def _na(self, what: str) -> None: ...
+        def accept(self) -> tuple[socket.socket, _RetAddress]: ...
+        def connect(self, address: _Address) -> None: ...
+        def connect_ex(self, address: _Address) -> int: ...
+        def bind(self, address: _Address) -> None: ...
+        if sys.platform == "win32":
+            def ioctl(
+                self, control: int, option: int | tuple[int, int, int] | bool
+            ) -> None: ...
+        else:
+            def ioctl(
+                self, control: int, option: int | tuple[int, int, int] | bool
+            ) -> NoReturn: ...
+
+        def listen(self, __backlog: int = ...) -> None: ...
+        def makefile(self) -> BinaryIO: ...
+        def sendfile(
+            self, file: BinaryIO, offset: int = ..., count: int | None = ...
+        ) -> int: ...
+        def close(self) -> None: ...
+        def detach(self) -> int: ...
+        if sys.platform == "linux":
+            def sendmsg_afalg(
+                self,
+                msg: Iterable[ReadableBuffer] = ...,
+                *,
+                op: int,
+                iv: Any = ...,
+                assoclen: int = ...,
+                flags: int = ...
+            ) -> int: ...
+        else:
+            def sendmsg_afalg(
+                self,
+                msg: Iterable[ReadableBuffer] = ...,
+                *,
+                op: int,
+                iv: Any = ...,
+                assoclen: int = ...,
+                flags: int = ...
+            ) -> NoReturn: ...
+
+        def sendmsg(
+            self,
+            __buffers: Iterable[ReadableBuffer],
+            __ancdata: Iterable[_CMSG] = ...,
+            __flags: int = ...,
+            __address: _Address = ...,
+        ) -> int: ...
+        @overload
+        def sendto(self, data: ReadableBuffer, address: _Address) -> int: ...
+        @overload
+        def sendto(
+            self, data: ReadableBuffer, flags: int, address: _Address
+        ) -> int: ...
+        def send(self, data: ReadableBuffer, flags: int = ...) -> int: ...
+        def sendall(self, data: ReadableBuffer, flags: int = ...) -> None: ...
+        def set_inheritable(self, inheritable: bool) -> None: ...
+        if sys.platform == "win32":
+            def share(self, process_id: int) -> bytes: ...
+        else:
+            def share(self, process_id: int) -> NoReturn: ...
+
+        def recv_into(
+            self, buffer: _WriteBuffer, nbytes: int = ..., flags: int = ...
+        ) -> int: ...
+        def recvfrom_into(
+            self, buffer: _WriteBuffer, nbytes: int = ..., flags: int = ...
+        ) -> tuple[int, _RetAddress]: ...
+        def recvmsg_into(
+            self,
+            __buffers: Iterable[_WriteBuffer],
+            __ancbufsize: int = ...,
+            __flags: int = ...,
+        ) -> tuple[int, list[_CMSG], int, Any]: ...
+        def recvmsg(
+            self, __bufsize: int, __ancbufsize: int = ..., __flags: int = ...
+        ) -> tuple[bytes, list[_CMSG], int, Any]: ...
+        def recvfrom(
+            self, bufsize: int, flags: int = ...
+        ) -> tuple[bytes, _RetAddress]: ...
+        def recv(self, bufsize: int, flags: int = ...) -> bytes: ...
+        def __enter__(self) -> socket.socket: ...
+        def __exit__(
+            self,
+            exc_type: Type[BaseException] | None,
+            exc_val: BaseException | None,
+            exc_tb: TracebackType | None,
+        ) -> None: ...

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

@@ -0,0 +1,268 @@
+import sys
+import types
+from abc import ABCMeta, abstractmethod
+from collections.abc import Callable
+from typing import Literal
+from typing_extensions import Self, TypeVarTuple, Unpack, deprecated
+
+from .events import AbstractEventLoop, BaseDefaultEventLoopPolicy
+from .selector_events import BaseSelectorEventLoop
+
+_Ts = TypeVarTuple("_Ts")
+
+# This is also technically not available on Win,
+# but other parts of typeshed need this definition.
+# So, it is special cased.
+if sys.version_info >= (3, 12):
+    @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+    class AbstractChildWatcher:
+        @abstractmethod
+        def add_child_handler(
+            self,
+            pid: int,
+            callback: Callable[[Unpack[_Ts]], object],
+            *args: Unpack[_Ts]
+        ) -> None: ...
+        @abstractmethod
+        def remove_child_handler(self, pid: int) -> bool: ...
+        @abstractmethod
+        def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+        @abstractmethod
+        def close(self) -> None: ...
+        @abstractmethod
+        def __enter__(self) -> Self: ...
+        @abstractmethod
+        def __exit__(
+            self,
+            typ: type[BaseException] | None,
+            exc: BaseException | None,
+            tb: types.TracebackType | None,
+        ) -> None: ...
+        @abstractmethod
+        def is_active(self) -> bool: ...
+
+else:
+    class AbstractChildWatcher:
+        @abstractmethod
+        def add_child_handler(
+            self,
+            pid: int,
+            callback: Callable[[Unpack[_Ts]], object],
+            *args: Unpack[_Ts]
+        ) -> None: ...
+        @abstractmethod
+        def remove_child_handler(self, pid: int) -> bool: ...
+        @abstractmethod
+        def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+        @abstractmethod
+        def close(self) -> None: ...
+        @abstractmethod
+        def __enter__(self) -> Self: ...
+        @abstractmethod
+        def __exit__(
+            self,
+            typ: type[BaseException] | None,
+            exc: BaseException | None,
+            tb: types.TracebackType | None,
+        ) -> None: ...
+        @abstractmethod
+        def is_active(self) -> bool: ...
+
+if sys.platform != "win32":
+    if sys.version_info >= (3, 9):
+        __all__ = (
+            "SelectorEventLoop",
+            "AbstractChildWatcher",
+            "SafeChildWatcher",
+            "FastChildWatcher",
+            "PidfdChildWatcher",
+            "MultiLoopChildWatcher",
+            "ThreadedChildWatcher",
+            "DefaultEventLoopPolicy",
+        )
+    else:
+        __all__ = (
+            "SelectorEventLoop",
+            "AbstractChildWatcher",
+            "SafeChildWatcher",
+            "FastChildWatcher",
+            "MultiLoopChildWatcher",
+            "ThreadedChildWatcher",
+            "DefaultEventLoopPolicy",
+        )
+
+    # Doesn't actually have ABCMeta metaclass at runtime, but mypy complains if we don't have it in the stub.
+    # See discussion in #7412
+    class BaseChildWatcher(AbstractChildWatcher, metaclass=ABCMeta):
+        def close(self) -> None: ...
+        def is_active(self) -> bool: ...
+        def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+
+    if sys.version_info >= (3, 12):
+        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+        class SafeChildWatcher(BaseChildWatcher):
+            def __enter__(self) -> Self: ...
+            def __exit__(
+                self,
+                a: type[BaseException] | None,
+                b: BaseException | None,
+                c: types.TracebackType | None,
+            ) -> None: ...
+            def add_child_handler(
+                self,
+                pid: int,
+                callback: Callable[[Unpack[_Ts]], object],
+                *args: Unpack[_Ts]
+            ) -> None: ...
+            def remove_child_handler(self, pid: int) -> bool: ...
+
+        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+        class FastChildWatcher(BaseChildWatcher):
+            def __enter__(self) -> Self: ...
+            def __exit__(
+                self,
+                a: type[BaseException] | None,
+                b: BaseException | None,
+                c: types.TracebackType | None,
+            ) -> None: ...
+            def add_child_handler(
+                self,
+                pid: int,
+                callback: Callable[[Unpack[_Ts]], object],
+                *args: Unpack[_Ts]
+            ) -> None: ...
+            def remove_child_handler(self, pid: int) -> bool: ...
+
+    else:
+        class SafeChildWatcher(BaseChildWatcher):
+            def __enter__(self) -> Self: ...
+            def __exit__(
+                self,
+                a: type[BaseException] | None,
+                b: BaseException | None,
+                c: types.TracebackType | None,
+            ) -> None: ...
+            def add_child_handler(
+                self,
+                pid: int,
+                callback: Callable[[Unpack[_Ts]], object],
+                *args: Unpack[_Ts]
+            ) -> None: ...
+            def remove_child_handler(self, pid: int) -> bool: ...
+
+        class FastChildWatcher(BaseChildWatcher):
+            def __enter__(self) -> Self: ...
+            def __exit__(
+                self,
+                a: type[BaseException] | None,
+                b: BaseException | None,
+                c: types.TracebackType | None,
+            ) -> None: ...
+            def add_child_handler(
+                self,
+                pid: int,
+                callback: Callable[[Unpack[_Ts]], object],
+                *args: Unpack[_Ts]
+            ) -> None: ...
+            def remove_child_handler(self, pid: int) -> bool: ...
+
+    class _UnixSelectorEventLoop(BaseSelectorEventLoop): ...
+
+    class _UnixDefaultEventLoopPolicy(BaseDefaultEventLoopPolicy):
+        if sys.version_info >= (3, 12):
+            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+            def get_child_watcher(self) -> AbstractChildWatcher: ...
+            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+            def set_child_watcher(
+                self, watcher: AbstractChildWatcher | None
+            ) -> None: ...
+        else:
+            def get_child_watcher(self) -> AbstractChildWatcher: ...
+            def set_child_watcher(
+                self, watcher: AbstractChildWatcher | None
+            ) -> None: ...
+
+    SelectorEventLoop = _UnixSelectorEventLoop
+
+    DefaultEventLoopPolicy = _UnixDefaultEventLoopPolicy
+
+    if sys.version_info >= (3, 12):
+        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+        class MultiLoopChildWatcher(AbstractChildWatcher):
+            def is_active(self) -> bool: ...
+            def close(self) -> None: ...
+            def __enter__(self) -> Self: ...
+            def __exit__(
+                self,
+                exc_type: type[BaseException] | None,
+                exc_val: BaseException | None,
+                exc_tb: types.TracebackType | None,
+            ) -> None: ...
+            def add_child_handler(
+                self,
+                pid: int,
+                callback: Callable[[Unpack[_Ts]], object],
+                *args: Unpack[_Ts]
+            ) -> None: ...
+            def remove_child_handler(self, pid: int) -> bool: ...
+            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+
+    else:
+        class MultiLoopChildWatcher(AbstractChildWatcher):
+            def is_active(self) -> bool: ...
+            def close(self) -> None: ...
+            def __enter__(self) -> Self: ...
+            def __exit__(
+                self,
+                exc_type: type[BaseException] | None,
+                exc_val: BaseException | None,
+                exc_tb: types.TracebackType | None,
+            ) -> None: ...
+            def add_child_handler(
+                self,
+                pid: int,
+                callback: Callable[[Unpack[_Ts]], object],
+                *args: Unpack[_Ts]
+            ) -> None: ...
+            def remove_child_handler(self, pid: int) -> bool: ...
+            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+
+    class ThreadedChildWatcher(AbstractChildWatcher):
+        def is_active(self) -> Literal[True]: ...
+        def close(self) -> None: ...
+        def __enter__(self) -> Self: ...
+        def __exit__(
+            self,
+            exc_type: type[BaseException] | None,
+            exc_val: BaseException | None,
+            exc_tb: types.TracebackType | None,
+        ) -> None: ...
+        def __del__(self) -> None: ...
+        def add_child_handler(
+            self,
+            pid: int,
+            callback: Callable[[Unpack[_Ts]], object],
+            *args: Unpack[_Ts]
+        ) -> None: ...
+        def remove_child_handler(self, pid: int) -> bool: ...
+        def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+
+    if sys.version_info >= (3, 9):
+        class PidfdChildWatcher(AbstractChildWatcher):
+            def __enter__(self) -> Self: ...
+            def __exit__(
+                self,
+                exc_type: type[BaseException] | None,
+                exc_val: BaseException | None,
+                exc_tb: types.TracebackType | None,
+            ) -> None: ...
+            def is_active(self) -> bool: ...
+            def close(self) -> None: ...
+            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+            def add_child_handler(
+                self,
+                pid: int,
+                callback: Callable[[Unpack[_Ts]], object],
+                *args: Unpack[_Ts]
+            ) -> None: ...
+            def remove_child_handler(self, pid: int) -> bool: ...

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

@@ -0,0 +1,108 @@
+import socket
+import sys
+from _typeshed import Incomplete, ReadableBuffer, WriteableBuffer
+from collections.abc import Callable
+from typing import IO, Any, ClassVar, Literal, NoReturn
+
+from . import events, futures, proactor_events, selector_events, streams, windows_utils
+
+if sys.platform == "win32":
+    __all__ = (
+        "SelectorEventLoop",
+        "ProactorEventLoop",
+        "IocpProactor",
+        "DefaultEventLoopPolicy",
+        "WindowsSelectorEventLoopPolicy",
+        "WindowsProactorEventLoopPolicy",
+    )
+
+    NULL: Literal[0]
+    INFINITE: Literal[0xFFFFFFFF]
+    ERROR_CONNECTION_REFUSED: Literal[1225]
+    ERROR_CONNECTION_ABORTED: Literal[1236]
+    CONNECT_PIPE_INIT_DELAY: float
+    CONNECT_PIPE_MAX_DELAY: float
+
+    class PipeServer:
+        def __init__(self, address: str) -> None: ...
+        def __del__(self) -> None: ...
+        def closed(self) -> bool: ...
+        def close(self) -> None: ...
+
+    class _WindowsSelectorEventLoop(selector_events.BaseSelectorEventLoop): ...
+
+    class ProactorEventLoop(proactor_events.BaseProactorEventLoop):
+        def __init__(self, proactor: IocpProactor | None = None) -> None: ...
+        async def create_pipe_connection(
+            self,
+            protocol_factory: Callable[[], streams.StreamReaderProtocol],
+            address: str,
+        ) -> tuple[
+            proactor_events._ProactorDuplexPipeTransport, streams.StreamReaderProtocol
+        ]: ...
+        async def start_serving_pipe(
+            self,
+            protocol_factory: Callable[[], streams.StreamReaderProtocol],
+            address: str,
+        ) -> list[PipeServer]: ...
+
+    class IocpProactor:
+        def __init__(self, concurrency: int = 0xFFFFFFFF) -> None: ...
+        def __del__(self) -> None: ...
+        def set_loop(self, loop: events.AbstractEventLoop) -> None: ...
+        def select(self, timeout: int | None = None) -> list[futures.Future[Any]]: ...
+        def recv(
+            self, conn: socket.socket, nbytes: int, flags: int = 0
+        ) -> futures.Future[bytes]: ...
+        def recv_into(
+            self, conn: socket.socket, buf: WriteableBuffer, flags: int = 0
+        ) -> futures.Future[Any]: ...
+        def recvfrom(
+            self, conn: socket.socket, nbytes: int, flags: int = 0
+        ) -> futures.Future[tuple[bytes, socket._RetAddress]]: ...
+        def sendto(
+            self,
+            conn: socket.socket,
+            buf: ReadableBuffer,
+            flags: int = 0,
+            addr: socket._Address | None = None,
+        ) -> futures.Future[int]: ...
+        def send(
+            self, conn: socket.socket, buf: WriteableBuffer, flags: int = 0
+        ) -> futures.Future[Any]: ...
+        def accept(self, listener: socket.socket) -> futures.Future[Any]: ...
+        def connect(
+            self,
+            conn: socket.socket,
+            address: (
+                tuple[Incomplete, Incomplete]
+                | tuple[Incomplete, Incomplete, Incomplete, Incomplete]
+            ),
+        ) -> futures.Future[Any]: ...
+        def sendfile(
+            self, sock: socket.socket, file: IO[bytes], offset: int, count: int
+        ) -> futures.Future[Any]: ...
+        def accept_pipe(self, pipe: socket.socket) -> futures.Future[Any]: ...
+        async def connect_pipe(self, address: str) -> windows_utils.PipeHandle: ...
+        def wait_for_handle(
+            self, handle: windows_utils.PipeHandle, timeout: int | None = None
+        ) -> bool: ...
+        def close(self) -> None: ...
+        if sys.version_info >= (3, 11):
+            def recvfrom_into(
+                self, conn: socket.socket, buf: WriteableBuffer, flags: int = 0
+            ) -> futures.Future[tuple[int, socket._RetAddress]]: ...
+
+    SelectorEventLoop = _WindowsSelectorEventLoop
+
+    class WindowsSelectorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
+        _loop_factory: ClassVar[type[SelectorEventLoop]]
+        def get_child_watcher(self) -> NoReturn: ...
+        def set_child_watcher(self, watcher: Any) -> NoReturn: ...
+
+    class WindowsProactorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
+        _loop_factory: ClassVar[type[ProactorEventLoop]]
+        def get_child_watcher(self) -> NoReturn: ...
+        def set_child_watcher(self, watcher: Any) -> NoReturn: ...
+
+    DefaultEventLoopPolicy = WindowsSelectorEventLoopPolicy

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

@@ -0,0 +1,59 @@
+import subprocess
+import sys
+from collections.abc import Callable
+from types import TracebackType
+from typing import Any, AnyStr, Literal
+from typing_extensions import Self
+
+if sys.platform == "win32":
+    __all__ = ("pipe", "Popen", "PIPE", "PipeHandle")
+
+    BUFSIZE: Literal[8192]
+    PIPE = subprocess.PIPE
+    STDOUT = subprocess.STDOUT
+    def pipe(
+        *,
+        duplex: bool = False,
+        overlapped: tuple[bool, bool] = (True, True),
+        bufsize: int = 8192,
+    ) -> tuple[int, int]: ...
+
+    class PipeHandle:
+        def __init__(self, handle: int) -> None: ...
+        def __del__(self) -> None: ...
+        def __enter__(self) -> Self: ...
+        def __exit__(
+            self,
+            t: type[BaseException] | None,
+            v: BaseException | None,
+            tb: TracebackType | None,
+        ) -> None: ...
+        @property
+        def handle(self) -> int: ...
+        def fileno(self) -> int: ...
+        def close(self, *, CloseHandle: Callable[[int], object] = ...) -> None: ...
+
+    class Popen(subprocess.Popen[AnyStr]):
+        stdin: PipeHandle | None  # type: ignore[assignment]
+        stdout: PipeHandle | None  # type: ignore[assignment]
+        stderr: PipeHandle | None  # type: ignore[assignment]
+        # For simplicity we omit the full overloaded __new__ signature of
+        # subprocess.Popen. The arguments are mostly the same, but
+        # subprocess.Popen takes other positional-or-keyword arguments before
+        # stdin.
+        def __new__(
+            cls,
+            args: subprocess._CMD,
+            stdin: subprocess._FILE | None = ...,
+            stdout: subprocess._FILE | None = ...,
+            stderr: subprocess._FILE | None = ...,
+            **kwds: Any,
+        ) -> Self: ...
+        def __init__(
+            self,
+            args: subprocess._CMD,
+            stdin: subprocess._FILE | None = None,
+            stdout: subprocess._FILE | None = None,
+            stderr: subprocess._FILE | None = None,
+            **kwds: Any,
+        ) -> None: ...

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

@@ -0,0 +1,99 @@
+import sys
+from _typeshed import FileDescriptorLike, ReadableBuffer
+from socket import socket
+from typing import Any, overload
+from typing_extensions import TypeAlias
+
+# cyclic dependence with asynchat
+_MapType: TypeAlias = dict[int, Any]
+_Socket: TypeAlias = socket
+
+socket_map: _MapType  # undocumented
+
+class ExitNow(Exception): ...
+
+def read(obj: Any) -> None: ...
+def write(obj: Any) -> None: ...
+def readwrite(obj: Any, flags: int) -> None: ...
+def poll(timeout: float = 0.0, map: _MapType | None = None) -> None: ...
+def poll2(timeout: float = 0.0, map: _MapType | None = None) -> None: ...
+
+poll3 = poll2
+
+def loop(
+    timeout: float = 30.0,
+    use_poll: bool = False,
+    map: _MapType | None = None,
+    count: int | None = None,
+) -> None: ...
+
+# Not really subclass of socket.socket; it's only delegation.
+# It is not covariant to it.
+class dispatcher:
+    debug: bool
+    connected: bool
+    accepting: bool
+    connecting: bool
+    closing: bool
+    ignore_log_types: frozenset[str]
+    socket: _Socket | None
+    def __init__(
+        self, sock: _Socket | None = None, map: _MapType | None = None
+    ) -> None: ...
+    def add_channel(self, map: _MapType | None = None) -> None: ...
+    def del_channel(self, map: _MapType | None = None) -> None: ...
+    def create_socket(self, family: int = ..., type: int = ...) -> None: ...
+    def set_socket(self, sock: _Socket, map: _MapType | None = None) -> None: ...
+    def set_reuse_addr(self) -> None: ...
+    def readable(self) -> bool: ...
+    def writable(self) -> bool: ...
+    def listen(self, num: int) -> None: ...
+    def bind(self, addr: tuple[Any, ...] | str) -> None: ...
+    def connect(self, address: tuple[Any, ...] | str) -> None: ...
+    def accept(self) -> tuple[_Socket, Any] | None: ...
+    def send(self, data: ReadableBuffer) -> int: ...
+    def recv(self, buffer_size: int) -> bytes: ...
+    def close(self) -> None: ...
+    def log(self, message: Any) -> None: ...
+    def log_info(self, message: Any, type: str = "info") -> None: ...
+    def handle_read_event(self) -> None: ...
+    def handle_connect_event(self) -> None: ...
+    def handle_write_event(self) -> None: ...
+    def handle_expt_event(self) -> None: ...
+    def handle_error(self) -> None: ...
+    def handle_expt(self) -> None: ...
+    def handle_read(self) -> None: ...
+    def handle_write(self) -> None: ...
+    def handle_connect(self) -> None: ...
+    def handle_accept(self) -> None: ...
+    def handle_close(self) -> None: ...
+
+class dispatcher_with_send(dispatcher):
+    def initiate_send(self) -> None: ...
+    # incompatible signature:
+    # def send(self, data: bytes) -> int | None: ...
+
+def compact_traceback() -> tuple[tuple[str, str, str], type, type, str]: ...
+def close_all(map: _MapType | None = None, ignore_all: bool = False) -> None: ...
+
+if sys.platform != "win32":
+    class file_wrapper:
+        fd: int
+        def __init__(self, fd: int) -> None: ...
+        def recv(self, bufsize: int, flags: int = ...) -> bytes: ...
+        def send(self, data: bytes, flags: int = ...) -> int: ...
+        @overload
+        def getsockopt(self, level: int, optname: int, buflen: None = None) -> int: ...
+        @overload
+        def getsockopt(self, level: int, optname: int, buflen: int) -> bytes: ...
+        def read(self, bufsize: int, flags: int = ...) -> bytes: ...
+        def write(self, data: bytes, flags: int = ...) -> int: ...
+        def close(self) -> None: ...
+        def fileno(self) -> int: ...
+        def __del__(self) -> None: ...
+
+    class file_dispatcher(dispatcher):
+        def __init__(
+            self, fd: FileDescriptorLike, map: _MapType | None = None
+        ) -> None: ...
+        def set_file(self, fd: int) -> None: ...

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

@@ -0,0 +1,14 @@
+from collections.abc import Callable
+from typing import TypeVar
+from typing_extensions import ParamSpec
+
+_T = TypeVar("_T")
+_P = ParamSpec("_P")
+
+def _clear() -> None: ...
+def _ncallbacks() -> int: ...
+def _run_exitfuncs() -> None: ...
+def register(
+    func: Callable[_P, _T], *args: _P.args, **kwargs: _P.kwargs
+) -> Callable[_P, _T]: ...
+def unregister(func: Callable[..., object]) -> None: ...