layermap 0.1.0

package/analyzers/project-map-python/typeshed/stdlib/shutil.pyi

@@ -0,0 +1,243 @@
+import os
+import sys
+from _typeshed import BytesPath, ExcInfo, FileDescriptorOrPath, MaybeNone, StrOrBytesPath, StrPath, SupportsRead, SupportsWrite
+from collections.abc import Callable, Iterable, Sequence
+from tarfile import _TarfileFilter
+from typing import Any, AnyStr, NamedTuple, NoReturn, Protocol, TypeAlias, TypeVar, overload, type_check_only
+from typing_extensions import deprecated
+
+__all__ = [
+    "copyfileobj",
+    "copyfile",
+    "copymode",
+    "copystat",
+    "copy",
+    "copy2",
+    "copytree",
+    "move",
+    "rmtree",
+    "Error",
+    "SpecialFileError",
+    "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",
+]
+if sys.version_info < (3, 14):
+    __all__ += ["ExecError"]
+
+_StrOrBytesPathT = TypeVar("_StrOrBytesPathT", bound=StrOrBytesPath)
+_StrPathT = TypeVar("_StrPathT", bound=StrPath)
+_BytesPathT = TypeVar("_BytesPathT", bound=BytesPath)
+
+class Error(OSError): ...
+class SameFileError(Error): ...
+class SpecialFileError(OSError): ...
+
+if sys.version_info >= (3, 14):
+    ExecError = RuntimeError  # Deprecated in Python 3.14; removal scheduled for Python 3.16
+
+else:
+    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: _StrPathT, *, follow_symlinks: bool = True) -> _StrPathT | str: ...
+@overload
+def copy(src: BytesPath, dst: _BytesPathT, *, follow_symlinks: bool = True) -> _BytesPathT | bytes: ...
+
+@overload
+def copy2(src: StrPath, dst: _StrPathT, *, follow_symlinks: bool = True) -> _StrPathT | str: ...
+@overload
+def copy2(src: BytesPath, dst: _BytesPathT, *, follow_symlinks: bool = True) -> _BytesPathT | bytes: ...
+
+def ignore_patterns(*patterns: StrPath) -> Callable[[Any, list[str]], set[str]]: ...
+def copytree(
+    src: StrPath,
+    dst: _StrPathT,
+    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,
+) -> _StrPathT: ...
+
+_OnErrorCallback: TypeAlias = Callable[[Callable[..., Any], str, ExcInfo], object]
+_OnExcCallback: TypeAlias = Callable[[Callable[..., Any], str, BaseException], object]
+
+@type_check_only
+class _RmtreeType(Protocol):
+    avoids_symlink_attacks: bool
+    if sys.version_info >= (3, 12):
+        @overload
+        @deprecated("The `onerror` parameter is deprecated. Use `onexc` instead.")
+        def __call__(
+            self,
+            path: StrOrBytesPath,
+            ignore_errors: bool,
+            onerror: _OnErrorCallback | None,
+            *,
+            onexc: None = None,
+            dir_fd: int | None = None,
+        ) -> None: ...
+        @overload
+        @deprecated("The `onerror` parameter is deprecated. Use `onexc` instead.")
+        def __call__(
+            self,
+            path: StrOrBytesPath,
+            ignore_errors: bool = False,
+            *,
+            onerror: _OnErrorCallback | None,
+            onexc: None = None,
+            dir_fd: int | None = None,
+        ) -> None: ...
+        @overload
+        def __call__(
+            self,
+            path: StrOrBytesPath,
+            ignore_errors: bool = False,
+            *,
+            onexc: _OnExcCallback | None = None,
+            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)
+def move(src: StrPath, dst: _StrPathT, copy_function: _CopyFn = ...) -> _StrPathT | str | MaybeNone: ...
+
+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__.
+if sys.version_info >= (3, 13):
+    @overload
+    def chown(
+        path: FileDescriptorOrPath,
+        user: str | int,
+        group: None = None,
+        *,
+        dir_fd: int | None = None,
+        follow_symlinks: bool = True,
+    ) -> None: ...
+    @overload
+    def chown(
+        path: FileDescriptorOrPath,
+        user: None = None,
+        *,
+        group: str | int,
+        dir_fd: int | None = None,
+        follow_symlinks: bool = True,
+    ) -> None: ...
+    @overload
+    def chown(
+        path: FileDescriptorOrPath, user: None, group: str | int, *, dir_fd: int | None = None, follow_symlinks: bool = True
+    ) -> None: ...
+    @overload
+    def chown(
+        path: FileDescriptorOrPath, user: str | int, group: str | int, *, dir_fd: int | None = None, follow_symlinks: bool = True
+    ) -> None: ...
+else:
+    @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: ...
+
+if sys.platform == "win32" and sys.version_info < (3, 12):
+    @overload
+    @deprecated("On Windows before Python 3.12, using a PathLike as `cmd` would always fail or return `None`.")
+    def which(cmd: os.PathLike[str], mode: int = 1, path: StrPath | None = None) -> NoReturn: ...
+
+@overload
+def which(cmd: StrPath, mode: int = 1, path: StrPath | None = None) -> str | 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: ...

package/analyzers/project-map-python/typeshed/stdlib/signal.pyi

@@ -0,0 +1,174 @@
+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, TypeAlias, final
+from typing_extensions import Never
+
+NSIG: int
+
+class Signals(IntEnum):
+    SIGFPE = 8
+    SIGILL = 4
+    SIGINT = 2
+    SIGSEGV = 11
+    SIGTERM = 15
+
+    if sys.platform == "win32":
+        SIGABRT = 22
+        SIGBREAK = 21
+        CTRL_C_EVENT = 0
+        CTRL_BREAK_EVENT = 1
+    else:
+        SIGABRT = 6
+        SIGALRM = 14
+        SIGBUS = 7
+        SIGCHLD = 17
+        SIGCONT = 18
+        SIGHUP = 1
+        SIGIO = 29
+        SIGIOT = 6
+        SIGKILL = 9
+        SIGPIPE = 13
+        SIGPROF = 27
+        SIGQUIT = 3
+        SIGSTOP = 19
+        SIGSYS = 31
+        SIGTRAP = 5
+        SIGTSTP = 20
+        SIGTTIN = 21
+        SIGTTOU = 22
+        SIGURG = 23
+        SIGUSR1 = 10
+        SIGUSR2 = 12
+        SIGVTALRM = 26
+        SIGWINCH = 28
+        SIGXCPU = 24
+        SIGXFSZ = 25
+        if sys.platform != "linux":
+            SIGEMT = 7
+            SIGINFO = 29
+        if sys.platform != "darwin":
+            SIGCLD = 17
+            SIGPOLL = 29
+            SIGPWR = 30
+            SIGRTMAX = 64
+            SIGRTMIN = 34
+            if sys.version_info >= (3, 11):
+                SIGSTKFLT = 16
+
+class Handlers(IntEnum):
+    SIG_DFL = 0
+    SIG_IGN = 1
+
+SIG_DFL: Final = Handlers.SIG_DFL
+SIG_IGN: Final = Handlers.SIG_IGN
+
+_SIGNUM: TypeAlias = int | Signals
+_HANDLER: TypeAlias = Callable[[int, FrameType | None], Any] | int | Handlers | None
+
+def default_int_handler(signalnum: int, frame: FrameType | None, /) -> Never: ...
+def getsignal(signalnum: _SIGNUM) -> _HANDLER: ...
+def signal(signalnum: _SIGNUM, handler: _HANDLER) -> _HANDLER: ...
+
+SIGABRT: Final = Signals.SIGABRT
+SIGFPE: Final = Signals.SIGFPE
+SIGILL: Final = Signals.SIGILL
+SIGINT: Final = Signals.SIGINT
+SIGSEGV: Final = Signals.SIGSEGV
+SIGTERM: Final = Signals.SIGTERM
+
+if sys.platform == "win32":
+    SIGBREAK: Final = Signals.SIGBREAK
+    CTRL_C_EVENT: Final = Signals.CTRL_C_EVENT
+    CTRL_BREAK_EVENT: Final = Signals.CTRL_BREAK_EVENT
+else:
+    if sys.platform != "linux":
+        SIGINFO: Final = Signals.SIGINFO
+        SIGEMT: Final = Signals.SIGEMT
+    SIGALRM: Final = Signals.SIGALRM
+    SIGBUS: Final = Signals.SIGBUS
+    SIGCHLD: Final = Signals.SIGCHLD
+    SIGCONT: Final = Signals.SIGCONT
+    SIGHUP: Final = Signals.SIGHUP
+    SIGIO: Final = Signals.SIGIO
+    SIGIOT: Final = Signals.SIGABRT  # alias
+    SIGKILL: Final = Signals.SIGKILL
+    SIGPIPE: Final = Signals.SIGPIPE
+    SIGPROF: Final = Signals.SIGPROF
+    SIGQUIT: Final = Signals.SIGQUIT
+    SIGSTOP: Final = Signals.SIGSTOP
+    SIGSYS: Final = Signals.SIGSYS
+    SIGTRAP: Final = Signals.SIGTRAP
+    SIGTSTP: Final = Signals.SIGTSTP
+    SIGTTIN: Final = Signals.SIGTTIN
+    SIGTTOU: Final = Signals.SIGTTOU
+    SIGURG: Final = Signals.SIGURG
+    SIGUSR1: Final = Signals.SIGUSR1
+    SIGUSR2: Final = Signals.SIGUSR2
+    SIGVTALRM: Final = Signals.SIGVTALRM
+    SIGWINCH: Final = Signals.SIGWINCH
+    SIGXCPU: Final = Signals.SIGXCPU
+    SIGXFSZ: Final = Signals.SIGXFSZ
+
+    class ItimerError(OSError): ...
+    ITIMER_PROF: int
+    ITIMER_REAL: int
+    ITIMER_VIRTUAL: int
+
+    class Sigmasks(IntEnum):
+        SIG_BLOCK = 0
+        SIG_UNBLOCK = 1
+        SIG_SETMASK = 2
+
+    SIG_BLOCK: Final = Sigmasks.SIG_BLOCK
+    SIG_UNBLOCK: Final = Sigmasks.SIG_UNBLOCK
+    SIG_SETMASK: Final = 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: ...
+    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: ...
+    def sigwait(sigset: Iterable[int]) -> _SIGNUM: ...
+    if sys.platform != "darwin":
+        SIGCLD: Final = Signals.SIGCHLD  # alias
+        SIGPOLL: Final = Signals.SIGIO  # alias
+        SIGPWR: Final = Signals.SIGPWR
+        SIGRTMAX: Final = Signals.SIGRTMAX
+        SIGRTMIN: Final = Signals.SIGRTMIN
+        if sys.version_info >= (3, 11):
+            SIGSTKFLT: Final = Signals.SIGSTKFLT
+
+        @final
+        class struct_siginfo(structseq[int], tuple[int, int, int, int, int, int, int]):
+            __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: ...
+
+        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 = True) -> int: ...
+
+if sys.platform == "linux":
+    def pidfd_send_signal(pidfd: int, sig: int, siginfo: None = None, flags: int = 0, /) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/site.pyi

@@ -0,0 +1,46 @@
+import sys
+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
+
+if sys.version_info >= (3, 15):
+    class StartupState:
+        __slots__ = ("_known_paths", "_processed_sitedirs", "_path_entries", "_importexecs", "_entrypoints")
+        def __init__(self, known_paths: set[str] | None = None) -> None: ...
+        def addsitedir(self, sitedir: str) -> None: ...
+        def addusersitepackages(self) -> None: ...
+        def addsitepackages(self, prefixes: Iterable[str] | None = None) -> None: ...
+        def process(self) -> None: ...
+
+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
+
+if sys.version_info >= (3, 13):
+    def gethistoryfile() -> str: ...  # undocumented
+
+def enablerlcompleter() -> None: ...  # undocumented
+
+if sys.version_info >= (3, 13):
+    def register_readline() -> 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

package/analyzers/project-map-python/typeshed/stdlib/smtpd.pyi

@@ -0,0 +1,92 @@
+import asynchat
+import asyncore
+import socket
+import sys
+from collections import defaultdict
+from typing import Any, TypeAlias
+from typing_extensions import deprecated
+
+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):
+    @deprecated("Deprecated since Python 3.9; removed in Python 3.11.")
+    class MailmanProxy(PureProxy):
+        def process_message(self, peer: _Address, mailfrom: str, rcpttos: list[str], data: bytes | str) -> str | None: ...  # type: ignore[override]