jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

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

@@ -1,196 +0,0 @@
-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[[int, int, 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[[int, int, 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[[int, int, 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[[int, int, 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[[int, int, 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[[int, int, 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[[int, int, 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[[int, int, 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[[int, int, 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[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-            ) -> None: ...
-            def remove_child_handler(self, pid: int) -> bool: ...

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

@@ -1,85 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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: ...

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

@@ -1,43 +0,0 @@
-from typing_extensions import TypeAlias
-
-_AdpcmState: TypeAlias = tuple[int, int]
-_RatecvState: TypeAlias = tuple[int, tuple[tuple[int, int], ...]]
-
-class error(Exception): ...
-
-def add(fragment1: bytes, fragment2: bytes, width: int, /) -> bytes: ...
-def adpcm2lin(fragment: bytes, width: int, state: _AdpcmState | None, /) -> tuple[bytes, _AdpcmState]: ...
-def alaw2lin(fragment: bytes, width: int, /) -> bytes: ...
-def avg(fragment: bytes, width: int, /) -> int: ...
-def avgpp(fragment: bytes, width: int, /) -> int: ...
-def bias(fragment: bytes, width: int, bias: int, /) -> bytes: ...
-def byteswap(fragment: bytes, width: int, /) -> bytes: ...
-def cross(fragment: bytes, width: int, /) -> int: ...
-def findfactor(fragment: bytes, reference: bytes, /) -> float: ...
-def findfit(fragment: bytes, reference: bytes, /) -> tuple[int, float]: ...
-def findmax(fragment: bytes, length: int, /) -> int: ...
-def getsample(fragment: bytes, width: int, index: int, /) -> int: ...
-def lin2adpcm(fragment: bytes, width: int, state: _AdpcmState | None, /) -> tuple[bytes, _AdpcmState]: ...
-def lin2alaw(fragment: bytes, width: int, /) -> bytes: ...
-def lin2lin(fragment: bytes, width: int, newwidth: int, /) -> bytes: ...
-def lin2ulaw(fragment: bytes, width: int, /) -> bytes: ...
-def max(fragment: bytes, width: int, /) -> int: ...
-def maxpp(fragment: bytes, width: int, /) -> int: ...
-def minmax(fragment: bytes, width: int, /) -> tuple[int, int]: ...
-def mul(fragment: bytes, width: int, factor: float, /) -> bytes: ...
-def ratecv(
-    fragment: bytes,
-    width: int,
-    nchannels: int,
-    inrate: int,
-    outrate: int,
-    state: _RatecvState | None,
-    weightA: int = 1,
-    weightB: int = 0,
-    /,
-) -> tuple[bytes, _RatecvState]: ...
-def reverse(fragment: bytes, width: int, /) -> bytes: ...
-def rms(fragment: bytes, width: int, /) -> int: ...
-def tomono(fragment: bytes, width: int, lfactor: float, rfactor: float, /) -> bytes: ...
-def tostereo(fragment: bytes, width: int, lfactor: float, rfactor: float, /) -> bytes: ...
-def ulaw2lin(fragment: bytes, width: int, /) -> bytes: ...

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

@@ -1,59 +0,0 @@
-import sys
-from _typeshed import ReadableBuffer
-from typing import IO
-
-__all__ = [
-    "encode",
-    "decode",
-    "encodebytes",
-    "decodebytes",
-    "b64encode",
-    "b64decode",
-    "b32encode",
-    "b32decode",
-    "b16encode",
-    "b16decode",
-    "b85encode",
-    "b85decode",
-    "a85encode",
-    "a85decode",
-    "standard_b64encode",
-    "standard_b64decode",
-    "urlsafe_b64encode",
-    "urlsafe_b64decode",
-]
-
-if sys.version_info >= (3, 10):
-    __all__ += ["b32hexencode", "b32hexdecode"]
-
-def b64encode(s: ReadableBuffer, altchars: ReadableBuffer | None = None) -> bytes: ...
-def b64decode(s: str | ReadableBuffer, altchars: str | ReadableBuffer | None = None, validate: bool = False) -> bytes: ...
-def standard_b64encode(s: ReadableBuffer) -> bytes: ...
-def standard_b64decode(s: str | ReadableBuffer) -> bytes: ...
-def urlsafe_b64encode(s: ReadableBuffer) -> bytes: ...
-def urlsafe_b64decode(s: str | ReadableBuffer) -> bytes: ...
-def b32encode(s: ReadableBuffer) -> bytes: ...
-def b32decode(s: str | ReadableBuffer, casefold: bool = False, map01: str | ReadableBuffer | None = None) -> bytes: ...
-def b16encode(s: ReadableBuffer) -> bytes: ...
-def b16decode(s: str | ReadableBuffer, casefold: bool = False) -> bytes: ...
-
-if sys.version_info >= (3, 10):
-    def b32hexencode(s: ReadableBuffer) -> bytes: ...
-    def b32hexdecode(s: str | ReadableBuffer, casefold: bool = False) -> bytes: ...
-
-def a85encode(
-    b: ReadableBuffer, *, foldspaces: bool = False, wrapcol: int = 0, pad: bool = False, adobe: bool = False
-) -> bytes: ...
-def a85decode(
-    b: str | ReadableBuffer, *, foldspaces: bool = False, adobe: bool = False, ignorechars: bytearray | bytes = b" \t\n\r\x0b"
-) -> bytes: ...
-def b85encode(b: ReadableBuffer, pad: bool = False) -> bytes: ...
-def b85decode(b: str | ReadableBuffer) -> bytes: ...
-def decode(input: IO[bytes], output: IO[bytes]) -> None: ...
-def encode(input: IO[bytes], output: IO[bytes]) -> None: ...
-def encodebytes(s: ReadableBuffer) -> bytes: ...
-def decodebytes(s: ReadableBuffer) -> bytes: ...
-
-if sys.version_info < (3, 9):
-    def encodestring(s: ReadableBuffer) -> bytes: ...
-    def decodestring(s: ReadableBuffer) -> bytes: ...

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

@@ -1,102 +0,0 @@
-import sys
-from _typeshed import ExcInfo, TraceFunction
-from collections.abc import Callable, Iterable, Mapping
-from types import CodeType, FrameType, TracebackType
-from typing import IO, Any, Literal, SupportsInt, TypeVar
-from typing_extensions import ParamSpec
-
-__all__ = ["BdbQuit", "Bdb", "Breakpoint"]
-
-_T = TypeVar("_T")
-_P = ParamSpec("_P")
-
-GENERATOR_AND_COROUTINE_FLAGS: Literal[672]
-
-class BdbQuit(Exception): ...
-
-class Bdb:
-    skip: set[str] | None
-    breaks: dict[str, list[int]]
-    fncache: dict[str, str]
-    frame_returning: FrameType | None
-    botframe: FrameType | None
-    quitting: bool
-    stopframe: FrameType | None
-    returnframe: FrameType | None
-    stoplineno: int
-    def __init__(self, skip: Iterable[str] | None = None) -> None: ...
-    def canonic(self, filename: str) -> str: ...
-    def reset(self) -> None: ...
-    def trace_dispatch(self, frame: FrameType, event: str, arg: Any) -> TraceFunction: ...
-    def dispatch_line(self, frame: FrameType) -> TraceFunction: ...
-    def dispatch_call(self, frame: FrameType, arg: None) -> TraceFunction: ...
-    def dispatch_return(self, frame: FrameType, arg: Any) -> TraceFunction: ...
-    def dispatch_exception(self, frame: FrameType, arg: ExcInfo) -> TraceFunction: ...
-    def is_skipped_module(self, module_name: str) -> bool: ...
-    def stop_here(self, frame: FrameType) -> bool: ...
-    def break_here(self, frame: FrameType) -> bool: ...
-    def do_clear(self, arg: Any) -> bool | None: ...
-    def break_anywhere(self, frame: FrameType) -> bool: ...
-    def user_call(self, frame: FrameType, argument_list: None) -> None: ...
-    def user_line(self, frame: FrameType) -> None: ...
-    def user_return(self, frame: FrameType, return_value: Any) -> None: ...
-    def user_exception(self, frame: FrameType, exc_info: ExcInfo) -> None: ...
-    def set_until(self, frame: FrameType, lineno: int | None = None) -> None: ...
-    def set_step(self) -> None: ...
-    def set_next(self, frame: FrameType) -> None: ...
-    def set_return(self, frame: FrameType) -> None: ...
-    def set_trace(self, frame: FrameType | None = None) -> None: ...
-    def set_continue(self) -> None: ...
-    def set_quit(self) -> None: ...
-    def set_break(
-        self, filename: str, lineno: int, temporary: bool = False, cond: str | None = None, funcname: str | None = None
-    ) -> str | None: ...
-    def clear_break(self, filename: str, lineno: int) -> str | None: ...
-    def clear_bpbynumber(self, arg: SupportsInt) -> str | None: ...
-    def clear_all_file_breaks(self, filename: str) -> str | None: ...
-    def clear_all_breaks(self) -> str | None: ...
-    def get_bpbynumber(self, arg: SupportsInt) -> Breakpoint: ...
-    def get_break(self, filename: str, lineno: int) -> bool: ...
-    def get_breaks(self, filename: str, lineno: int) -> list[Breakpoint]: ...
-    def get_file_breaks(self, filename: str) -> list[Breakpoint]: ...
-    def get_all_breaks(self) -> list[Breakpoint]: ...
-    def get_stack(self, f: FrameType | None, t: TracebackType | None) -> tuple[list[tuple[FrameType, int]], int]: ...
-    def format_stack_entry(self, frame_lineno: int, lprefix: str = ": ") -> str: ...
-    def run(
-        self, cmd: str | CodeType, globals: dict[str, Any] | None = None, locals: Mapping[str, Any] | None = None
-    ) -> None: ...
-    def runeval(self, expr: str, globals: dict[str, Any] | None = None, locals: Mapping[str, Any] | None = None) -> None: ...
-    def runctx(self, cmd: str | CodeType, globals: dict[str, Any] | None, locals: Mapping[str, Any] | None) -> None: ...
-    def runcall(self, func: Callable[_P, _T], /, *args: _P.args, **kwds: _P.kwargs) -> _T | None: ...
-
-class Breakpoint:
-    next: int
-    bplist: dict[tuple[str, int], list[Breakpoint]]
-    bpbynumber: list[Breakpoint | None]
-
-    funcname: str | None
-    func_first_executable_line: int | None
-    file: str
-    line: int
-    temporary: bool
-    cond: str | None
-    enabled: bool
-    ignore: int
-    hits: int
-    number: int
-    def __init__(
-        self, file: str, line: int, temporary: bool = False, cond: str | None = None, funcname: str | None = None
-    ) -> None: ...
-    if sys.version_info >= (3, 11):
-        @staticmethod
-        def clearBreakpoints() -> None: ...
-
-    def deleteMe(self) -> None: ...
-    def enable(self) -> None: ...
-    def disable(self) -> None: ...
-    def bpprint(self, out: IO[str] | None = None) -> None: ...
-    def bpformat(self) -> str: ...
-
-def checkfuncname(b: Breakpoint, frame: FrameType) -> bool: ...
-def effective(file: str, line: int, frame: FrameType) -> tuple[Breakpoint, bool] | tuple[None, None]: ...
-def set_trace() -> None: ...

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

@@ -1,36 +0,0 @@
-import sys
-from _typeshed import ReadableBuffer
-from typing_extensions import TypeAlias
-
-# Many functions in binascii accept buffer objects
-# or ASCII-only strings.
-_AsciiBuffer: TypeAlias = str | ReadableBuffer
-
-def a2b_uu(data: _AsciiBuffer, /) -> bytes: ...
-def b2a_uu(data: ReadableBuffer, /, *, backtick: bool = False) -> bytes: ...
-
-if sys.version_info >= (3, 11):
-    def a2b_base64(data: _AsciiBuffer, /, *, strict_mode: bool = False) -> bytes: ...
-
-else:
-    def a2b_base64(data: _AsciiBuffer, /) -> bytes: ...
-
-def b2a_base64(data: ReadableBuffer, /, *, newline: bool = True) -> bytes: ...
-def a2b_qp(data: _AsciiBuffer, header: bool = False) -> bytes: ...
-def b2a_qp(data: ReadableBuffer, quotetabs: bool = False, istext: bool = True, header: bool = False) -> bytes: ...
-
-if sys.version_info < (3, 11):
-    def a2b_hqx(data: _AsciiBuffer, /) -> bytes: ...
-    def rledecode_hqx(data: ReadableBuffer, /) -> bytes: ...
-    def rlecode_hqx(data: ReadableBuffer, /) -> bytes: ...
-    def b2a_hqx(data: ReadableBuffer, /) -> bytes: ...
-
-def crc_hqx(data: ReadableBuffer, crc: int, /) -> int: ...
-def crc32(data: ReadableBuffer, crc: int = 0, /) -> int: ...
-def b2a_hex(data: ReadableBuffer, sep: str | bytes = ..., bytes_per_sep: int = ...) -> bytes: ...
-def hexlify(data: ReadableBuffer, sep: str | bytes = ..., bytes_per_sep: int = ...) -> bytes: ...
-def a2b_hex(hexstr: _AsciiBuffer, /) -> bytes: ...
-def unhexlify(hexstr: _AsciiBuffer, /) -> bytes: ...
-
-class Error(ValueError): ...
-class Incomplete(Exception): ...