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

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

@@ -0,0 +1,239 @@
+import os
+import sys
+from _typeshed import (
+    BytesPath,
+    FileDescriptorOrPath,
+    StrOrBytesPath,
+    StrPath,
+    SupportsRead,
+    SupportsWrite,
+)
+from collections.abc import Callable, Iterable, Sequence
+from tarfile import _TarfileFilter
+from typing import Any, AnyStr, NamedTuple, Protocol, TypeVar, overload
+from typing_extensions import TypeAlias
+
+__all__ = [
+    "copyfileobj",
+    "copyfile",
+    "copymode",
+    "copystat",
+    "copy",
+    "copy2",
+    "copytree",
+    "move",
+    "rmtree",
+    "Error",
+    "SpecialFileError",
+    "ExecError",
+    "make_archive",
+    "get_archive_formats",
+    "register_archive_format",
+    "unregister_archive_format",
+    "get_unpack_formats",
+    "register_unpack_format",
+    "unregister_unpack_format",
+    "unpack_archive",
+    "ignore_patterns",
+    "chown",
+    "which",
+    "get_terminal_size",
+    "SameFileError",
+    "disk_usage",
+]
+
+_StrOrBytesPathT = TypeVar("_StrOrBytesPathT", bound=StrOrBytesPath)
+_StrPathT = TypeVar("_StrPathT", bound=StrPath)
+# Return value of some functions that may either return a path-like object that was passed in or
+# a string
+_PathReturn: TypeAlias = Any
+
+class Error(OSError): ...
+class SameFileError(Error): ...
+class SpecialFileError(OSError): ...
+class ExecError(OSError): ...
+class ReadError(OSError): ...
+class RegistryError(Exception): ...
+
+def copyfileobj(
+    fsrc: SupportsRead[AnyStr], fdst: SupportsWrite[AnyStr], length: int = 0
+) -> None: ...
+def copyfile(
+    src: StrOrBytesPath, dst: _StrOrBytesPathT, *, follow_symlinks: bool = True
+) -> _StrOrBytesPathT: ...
+def copymode(
+    src: StrOrBytesPath, dst: StrOrBytesPath, *, follow_symlinks: bool = True
+) -> None: ...
+def copystat(
+    src: StrOrBytesPath, dst: StrOrBytesPath, *, follow_symlinks: bool = True
+) -> None: ...
+@overload
+def copy(
+    src: StrPath, dst: StrPath, *, follow_symlinks: bool = True
+) -> _PathReturn: ...
+@overload
+def copy(
+    src: BytesPath, dst: BytesPath, *, follow_symlinks: bool = True
+) -> _PathReturn: ...
+@overload
+def copy2(
+    src: StrPath, dst: StrPath, *, follow_symlinks: bool = True
+) -> _PathReturn: ...
+@overload
+def copy2(
+    src: BytesPath, dst: BytesPath, *, follow_symlinks: bool = True
+) -> _PathReturn: ...
+def ignore_patterns(*patterns: StrPath) -> Callable[[Any, list[str]], set[str]]: ...
+def copytree(
+    src: StrPath,
+    dst: StrPath,
+    symlinks: bool = False,
+    ignore: (
+        None
+        | Callable[[str, list[str]], Iterable[str]]
+        | Callable[[StrPath, list[str]], Iterable[str]]
+    ) = None,
+    copy_function: Callable[[str, str], object] = ...,
+    ignore_dangling_symlinks: bool = False,
+    dirs_exist_ok: bool = False,
+) -> _PathReturn: ...
+
+_OnErrorCallback: TypeAlias = Callable[[Callable[..., Any], str, Any], object]
+_OnExcCallback: TypeAlias = Callable[[Callable[..., Any], str, Exception], object]
+
+class _RmtreeType(Protocol):
+    avoids_symlink_attacks: bool
+    if sys.version_info >= (3, 12):
+        @overload
+        def __call__(
+            self,
+            path: StrOrBytesPath,
+            ignore_errors: bool = False,
+            onerror: _OnErrorCallback | None = None,
+            *,
+            onexc: None = None,
+            dir_fd: int | None = None,
+        ) -> None: ...
+        @overload
+        def __call__(
+            self,
+            path: StrOrBytesPath,
+            ignore_errors: bool = False,
+            onerror: None = None,
+            *,
+            onexc: _OnExcCallback,
+            dir_fd: int | None = None,
+        ) -> None: ...
+    elif sys.version_info >= (3, 11):
+        def __call__(
+            self,
+            path: StrOrBytesPath,
+            ignore_errors: bool = False,
+            onerror: _OnErrorCallback | None = None,
+            *,
+            dir_fd: int | None = None,
+        ) -> None: ...
+
+    else:
+        def __call__(
+            self,
+            path: StrOrBytesPath,
+            ignore_errors: bool = False,
+            onerror: _OnErrorCallback | None = None,
+        ) -> None: ...
+
+rmtree: _RmtreeType
+
+_CopyFn: TypeAlias = Callable[[str, str], object] | Callable[[StrPath, StrPath], object]
+
+# N.B. shutil.move appears to take bytes arguments, however,
+# this does not work when dst is (or is within) an existing directory.
+# (#6832)
+if sys.version_info >= (3, 9):
+    def move(
+        src: StrPath, dst: StrPath, copy_function: _CopyFn = ...
+    ) -> _PathReturn: ...
+
+else:
+    # See https://bugs.python.org/issue32689
+    def move(src: str, dst: StrPath, copy_function: _CopyFn = ...) -> _PathReturn: ...
+
+class _ntuple_diskusage(NamedTuple):
+    total: int
+    used: int
+    free: int
+
+def disk_usage(path: FileDescriptorOrPath) -> _ntuple_diskusage: ...
+
+# While chown can be imported on Windows, it doesn't actually work;
+# see https://bugs.python.org/issue33140. We keep it here because it's
+# in __all__.
+@overload
+def chown(path: FileDescriptorOrPath, user: str | int, group: None = None) -> None: ...
+@overload
+def chown(
+    path: FileDescriptorOrPath, user: None = None, *, group: str | int
+) -> None: ...
+@overload
+def chown(path: FileDescriptorOrPath, user: None, group: str | int) -> None: ...
+@overload
+def chown(path: FileDescriptorOrPath, user: str | int, group: str | int) -> None: ...
+@overload
+def which(
+    cmd: _StrPathT, mode: int = 1, path: StrPath | None = None
+) -> str | _StrPathT | None: ...
+@overload
+def which(cmd: bytes, mode: int = 1, path: StrPath | None = None) -> bytes | None: ...
+def make_archive(
+    base_name: str,
+    format: str,
+    root_dir: StrPath | None = None,
+    base_dir: StrPath | None = None,
+    verbose: bool = ...,
+    dry_run: bool = ...,
+    owner: str | None = None,
+    group: str | None = None,
+    logger: Any | None = None,
+) -> str: ...
+def get_archive_formats() -> list[tuple[str, str]]: ...
+@overload
+def register_archive_format(
+    name: str,
+    function: Callable[..., object],
+    extra_args: Sequence[tuple[str, Any] | list[Any]],
+    description: str = "",
+) -> None: ...
+@overload
+def register_archive_format(
+    name: str,
+    function: Callable[[str, str], object],
+    extra_args: None = None,
+    description: str = "",
+) -> None: ...
+def unregister_archive_format(name: str) -> None: ...
+def unpack_archive(
+    filename: StrPath,
+    extract_dir: StrPath | None = None,
+    format: str | None = None,
+    *,
+    filter: _TarfileFilter | None = None,
+) -> None: ...
+@overload
+def register_unpack_format(
+    name: str,
+    extensions: list[str],
+    function: Callable[..., object],
+    extra_args: Sequence[tuple[str, Any]],
+    description: str = "",
+) -> None: ...
+@overload
+def register_unpack_format(
+    name: str,
+    extensions: list[str],
+    function: Callable[[str, str], object],
+    extra_args: None = None,
+    description: str = "",
+) -> None: ...
+def unregister_unpack_format(name: str) -> None: ...
+def get_unpack_formats() -> list[tuple[str, list[str], str]]: ...
+def get_terminal_size(fallback: tuple[int, int] = (80, 24)) -> os.terminal_size: ...

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

@@ -0,0 +1,208 @@
+import sys
+from _typeshed import structseq
+from collections.abc import Callable, Iterable
+from enum import IntEnum
+from types import FrameType
+from typing import Any, Final, final
+from typing_extensions import Never, TypeAlias
+
+NSIG: int
+
+class Signals(IntEnum):
+    SIGABRT: int
+    SIGFPE: int
+    SIGILL: int
+    SIGINT: int
+    SIGSEGV: int
+    SIGTERM: int
+
+    if sys.platform == "win32":
+        SIGBREAK: int
+        CTRL_C_EVENT: int
+        CTRL_BREAK_EVENT: int
+    else:
+        SIGALRM: int
+        SIGBUS: int
+        SIGCHLD: int
+        SIGCONT: int
+        SIGHUP: int
+        SIGIO: int
+        SIGIOT: int
+        SIGKILL: int
+        SIGPIPE: int
+        SIGPROF: int
+        SIGQUIT: int
+        SIGSTOP: int
+        SIGSYS: int
+        SIGTRAP: int
+        SIGTSTP: int
+        SIGTTIN: int
+        SIGTTOU: int
+        SIGURG: int
+        SIGUSR1: int
+        SIGUSR2: int
+        SIGVTALRM: int
+        SIGWINCH: int
+        SIGXCPU: int
+        SIGXFSZ: int
+        if sys.platform != "linux":
+            SIGEMT: int
+            SIGINFO: int
+        if sys.platform != "darwin":
+            SIGCLD: int
+            SIGPOLL: int
+            SIGPWR: int
+            SIGRTMAX: int
+            SIGRTMIN: int
+            if sys.version_info >= (3, 11):
+                SIGSTKFLT: int
+
+class Handlers(IntEnum):
+    SIG_DFL: int
+    SIG_IGN: int
+
+SIG_DFL: Handlers
+SIG_IGN: Handlers
+
+_SIGNUM: TypeAlias = int | Signals
+_HANDLER: TypeAlias = Callable[[int, FrameType | None], Any] | int | Handlers | None
+
+def default_int_handler(__signalnum: int, __frame: FrameType | None) -> Never: ...
+
+if sys.version_info >= (3, 10):  # arguments changed in 3.10.2
+    def getsignal(signalnum: _SIGNUM) -> _HANDLER: ...
+    def signal(signalnum: _SIGNUM, handler: _HANDLER) -> _HANDLER: ...
+
+else:
+    def getsignal(__signalnum: _SIGNUM) -> _HANDLER: ...
+    def signal(__signalnum: _SIGNUM, __handler: _HANDLER) -> _HANDLER: ...
+
+SIGABRT: Signals
+SIGFPE: Signals
+SIGILL: Signals
+SIGINT: Signals
+SIGSEGV: Signals
+SIGTERM: Signals
+
+if sys.platform == "win32":
+    SIGBREAK: Signals
+    CTRL_C_EVENT: Signals
+    CTRL_BREAK_EVENT: Signals
+else:
+    if sys.platform != "linux":
+        SIGINFO: Signals
+        SIGEMT: Signals
+    SIGALRM: Signals
+    SIGBUS: Signals
+    SIGCHLD: Signals
+    SIGCONT: Signals
+    SIGHUP: Signals
+    SIGIO: Signals
+    SIGIOT: Signals
+    SIGKILL: Signals
+    SIGPIPE: Signals
+    SIGPROF: Signals
+    SIGQUIT: Signals
+    SIGSTOP: Signals
+    SIGSYS: Signals
+    SIGTRAP: Signals
+    SIGTSTP: Signals
+    SIGTTIN: Signals
+    SIGTTOU: Signals
+    SIGURG: Signals
+    SIGUSR1: Signals
+    SIGUSR2: Signals
+    SIGVTALRM: Signals
+    SIGWINCH: Signals
+    SIGXCPU: Signals
+    SIGXFSZ: Signals
+
+    class ItimerError(OSError): ...
+    ITIMER_PROF: int
+    ITIMER_REAL: int
+    ITIMER_VIRTUAL: int
+
+    class Sigmasks(IntEnum):
+        SIG_BLOCK: int
+        SIG_UNBLOCK: int
+        SIG_SETMASK: int
+
+    SIG_BLOCK = Sigmasks.SIG_BLOCK
+    SIG_UNBLOCK = Sigmasks.SIG_UNBLOCK
+    SIG_SETMASK = Sigmasks.SIG_SETMASK
+    def alarm(__seconds: int) -> int: ...
+    def getitimer(__which: int) -> tuple[float, float]: ...
+    def pause() -> None: ...
+    def pthread_kill(__thread_id: int, __signalnum: int) -> None: ...
+    if sys.version_info >= (3, 10):  # arguments changed in 3.10.2
+        def pthread_sigmask(how: int, mask: Iterable[int]) -> set[_SIGNUM]: ...
+    else:
+        def pthread_sigmask(__how: int, __mask: Iterable[int]) -> set[_SIGNUM]: ...
+
+    def setitimer(
+        __which: int, __seconds: float, __interval: float = 0.0
+    ) -> tuple[float, float]: ...
+    def siginterrupt(__signalnum: int, __flag: bool) -> None: ...
+    def sigpending() -> Any: ...
+    if sys.version_info >= (3, 10):  # argument changed in 3.10.2
+        def sigwait(sigset: Iterable[int]) -> _SIGNUM: ...
+    else:
+        def sigwait(__sigset: Iterable[int]) -> _SIGNUM: ...
+    if sys.platform != "darwin":
+        SIGCLD: Signals
+        SIGPOLL: Signals
+        SIGPWR: Signals
+        SIGRTMAX: Signals
+        SIGRTMIN: Signals
+        if sys.version_info >= (3, 11):
+            SIGSTKFLT: Signals
+
+        @final
+        class struct_siginfo(structseq[int], tuple[int, int, int, int, int, int, int]):
+            if sys.version_info >= (3, 10):
+                __match_args__: Final = (
+                    "si_signo",
+                    "si_code",
+                    "si_errno",
+                    "si_pid",
+                    "si_uid",
+                    "si_status",
+                    "si_band",
+                )
+
+            @property
+            def si_signo(self) -> int: ...
+            @property
+            def si_code(self) -> int: ...
+            @property
+            def si_errno(self) -> int: ...
+            @property
+            def si_pid(self) -> int: ...
+            @property
+            def si_uid(self) -> int: ...
+            @property
+            def si_status(self) -> int: ...
+            @property
+            def si_band(self) -> int: ...
+
+        if sys.version_info >= (3, 10):
+            def sigtimedwait(
+                __sigset: Iterable[int], __timeout: float
+            ) -> struct_siginfo | None: ...
+            def sigwaitinfo(__sigset: Iterable[int]) -> struct_siginfo: ...
+        else:
+            def sigtimedwait(
+                sigset: Iterable[int], timeout: float
+            ) -> struct_siginfo | None: ...
+            def sigwaitinfo(sigset: Iterable[int]) -> struct_siginfo: ...
+
+def strsignal(__signalnum: _SIGNUM) -> str | None: ...
+def valid_signals() -> set[Signals]: ...
+def raise_signal(__signalnum: _SIGNUM) -> None: ...
+def set_wakeup_fd(fd: int, *, warn_on_full_buffer: bool = ...) -> int: ...
+
+if sys.version_info >= (3, 9):
+    if sys.platform == "linux":
+        def pidfd_send_signal(
+            __pidfd: int, __sig: int, __siginfo: None = None, __flags: int = ...
+        ) -> None: ...

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

@@ -0,0 +1,33 @@
+from _typeshed import StrPath
+from collections.abc import Iterable
+
+PREFIXES: list[str]
+ENABLE_USER_SITE: bool | None
+USER_SITE: str | None
+USER_BASE: str | None
+
+def main() -> None: ...
+def abs_paths() -> None: ...  # undocumented
+def addpackage(
+    sitedir: StrPath, name: StrPath, known_paths: set[str] | None
+) -> set[str] | None: ...  # undocumented
+def addsitedir(sitedir: str, known_paths: set[str] | None = None) -> None: ...
+def addsitepackages(
+    known_paths: set[str] | None, prefixes: Iterable[str] | None = None
+) -> set[str] | None: ...  # undocumented
+def addusersitepackages(
+    known_paths: set[str] | None,
+) -> set[str] | None: ...  # undocumented
+def check_enableusersite() -> bool | None: ...  # undocumented
+def enablerlcompleter() -> None: ...  # undocumented
+def execsitecustomize() -> None: ...  # undocumented
+def execusercustomize() -> None: ...  # undocumented
+def getsitepackages(prefixes: Iterable[str] | None = None) -> list[str]: ...
+def getuserbase() -> str: ...
+def getusersitepackages() -> str: ...
+def makepath(*paths: StrPath) -> tuple[str, str]: ...  # undocumented
+def removeduppaths() -> set[str]: ...  # undocumented
+def setcopyright() -> None: ...  # undocumented
+def sethelper() -> None: ...  # undocumented
+def setquit() -> None: ...  # undocumented
+def venv(known_paths: set[str] | None) -> set[str] | None: ...  # undocumented

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

@@ -0,0 +1,102 @@
+import asynchat
+import asyncore
+import socket
+import sys
+from collections import defaultdict
+from typing import Any
+from typing_extensions import TypeAlias
+
+if sys.version_info >= (3, 11):
+    __all__ = ["SMTPChannel", "SMTPServer", "DebuggingServer", "PureProxy"]
+else:
+    __all__ = [
+        "SMTPChannel",
+        "SMTPServer",
+        "DebuggingServer",
+        "PureProxy",
+        "MailmanProxy",
+    ]
+
+_Address: TypeAlias = tuple[str, int]  # (host, port)
+
+class SMTPChannel(asynchat.async_chat):
+    COMMAND: int
+    DATA: int
+
+    command_size_limits: defaultdict[str, int]
+    smtp_server: SMTPServer
+    conn: socket.socket
+    addr: Any
+    received_lines: list[str]
+    smtp_state: int
+    seen_greeting: str
+    mailfrom: str
+    rcpttos: list[str]
+    received_data: str
+    fqdn: str
+    peer: str
+
+    command_size_limit: int
+    data_size_limit: int
+
+    enable_SMTPUTF8: bool
+    @property
+    def max_command_size_limit(self) -> int: ...
+    def __init__(
+        self,
+        server: SMTPServer,
+        conn: socket.socket,
+        addr: Any,
+        data_size_limit: int = 33554432,
+        map: asyncore._MapType | None = None,
+        enable_SMTPUTF8: bool = False,
+        decode_data: bool = False,
+    ) -> None: ...
+    # base asynchat.async_chat.push() accepts bytes
+    def push(self, msg: str) -> None: ...  # type: ignore[override]
+    def collect_incoming_data(self, data: bytes) -> None: ...
+    def found_terminator(self) -> None: ...
+    def smtp_HELO(self, arg: str) -> None: ...
+    def smtp_NOOP(self, arg: str) -> None: ...
+    def smtp_QUIT(self, arg: str) -> None: ...
+    def smtp_MAIL(self, arg: str) -> None: ...
+    def smtp_RCPT(self, arg: str) -> None: ...
+    def smtp_RSET(self, arg: str) -> None: ...
+    def smtp_DATA(self, arg: str) -> None: ...
+    def smtp_EHLO(self, arg: str) -> None: ...
+    def smtp_HELP(self, arg: str) -> None: ...
+    def smtp_VRFY(self, arg: str) -> None: ...
+    def smtp_EXPN(self, arg: str) -> None: ...
+
+class SMTPServer(asyncore.dispatcher):
+    channel_class: type[SMTPChannel]
+
+    data_size_limit: int
+    enable_SMTPUTF8: bool
+    def __init__(
+        self,
+        localaddr: _Address,
+        remoteaddr: _Address,
+        data_size_limit: int = 33554432,
+        map: asyncore._MapType | None = None,
+        enable_SMTPUTF8: bool = False,
+        decode_data: bool = False,
+    ) -> None: ...
+    def handle_accepted(self, conn: socket.socket, addr: Any) -> None: ...
+    def process_message(
+        self,
+        peer: _Address,
+        mailfrom: str,
+        rcpttos: list[str],
+        data: bytes | str,
+        **kwargs: Any
+    ) -> str | None: ...
+
+class DebuggingServer(SMTPServer): ...
+
+class PureProxy(SMTPServer):
+    def process_message(self, peer: _Address, mailfrom: str, rcpttos: list[str], data: bytes | str) -> str | None: ...  # type: ignore[override]
+
+if sys.version_info < (3, 11):
+    class MailmanProxy(PureProxy):
+        def process_message(self, peer: _Address, mailfrom: str, rcpttos: list[str], data: bytes | str) -> str | None: ...  # type: ignore[override]