layermap 0.1.0

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

@@ -0,0 +1,116 @@
+import sys
+
+if sys.platform == "win32":
+    # Actually defined here and re-exported from os at runtime,
+    # but this leads to less code duplication
+    from os import (
+        F_OK as F_OK,
+        O_APPEND as O_APPEND,
+        O_BINARY as O_BINARY,
+        O_CREAT as O_CREAT,
+        O_EXCL as O_EXCL,
+        O_NOINHERIT as O_NOINHERIT,
+        O_RANDOM as O_RANDOM,
+        O_RDONLY as O_RDONLY,
+        O_RDWR as O_RDWR,
+        O_SEQUENTIAL as O_SEQUENTIAL,
+        O_SHORT_LIVED as O_SHORT_LIVED,
+        O_TEMPORARY as O_TEMPORARY,
+        O_TEXT as O_TEXT,
+        O_TRUNC as O_TRUNC,
+        O_WRONLY as O_WRONLY,
+        P_DETACH as P_DETACH,
+        P_NOWAIT as P_NOWAIT,
+        P_NOWAITO as P_NOWAITO,
+        P_OVERLAY as P_OVERLAY,
+        P_WAIT as P_WAIT,
+        R_OK as R_OK,
+        TMP_MAX as TMP_MAX,
+        W_OK as W_OK,
+        X_OK as X_OK,
+        DirEntry as DirEntry,
+        abort as abort,
+        access as access,
+        chdir as chdir,
+        chmod as chmod,
+        close as close,
+        closerange as closerange,
+        cpu_count as cpu_count,
+        device_encoding as device_encoding,
+        dup as dup,
+        dup2 as dup2,
+        error as error,
+        execv as execv,
+        execve as execve,
+        fspath as fspath,
+        fstat as fstat,
+        fsync as fsync,
+        ftruncate as ftruncate,
+        get_handle_inheritable as get_handle_inheritable,
+        get_inheritable as get_inheritable,
+        get_terminal_size as get_terminal_size,
+        getcwd as getcwd,
+        getcwdb as getcwdb,
+        getlogin as getlogin,
+        getpid as getpid,
+        getppid as getppid,
+        isatty as isatty,
+        kill as kill,
+        link as link,
+        listdir as listdir,
+        lseek as lseek,
+        lstat as lstat,
+        mkdir as mkdir,
+        open as open,
+        pipe as pipe,
+        putenv as putenv,
+        read as read,
+        readlink as readlink,
+        remove as remove,
+        rename as rename,
+        replace as replace,
+        rmdir as rmdir,
+        scandir as scandir,
+        set_handle_inheritable as set_handle_inheritable,
+        set_inheritable as set_inheritable,
+        spawnv as spawnv,
+        spawnve as spawnve,
+        startfile as startfile,
+        stat as stat,
+        stat_result as stat_result,
+        statvfs_result as statvfs_result,
+        strerror as strerror,
+        symlink as symlink,
+        system as system,
+        terminal_size as terminal_size,
+        times as times,
+        times_result as times_result,
+        truncate as truncate,
+        umask as umask,
+        uname_result as uname_result,
+        unlink as unlink,
+        unsetenv as unsetenv,
+        urandom as urandom,
+        utime as utime,
+        waitpid as waitpid,
+        waitstatus_to_exitcode as waitstatus_to_exitcode,
+        write as write,
+    )
+
+    if sys.version_info >= (3, 11):
+        from os import EX_OK as EX_OK
+    if sys.version_info >= (3, 12):
+        from os import (
+            get_blocking as get_blocking,
+            listdrives as listdrives,
+            listmounts as listmounts,
+            listvolumes as listvolumes,
+            set_blocking as set_blocking,
+        )
+    if sys.version_info >= (3, 13):
+        from os import fchmod as fchmod, lchmod as lchmod
+
+    if sys.version_info >= (3, 14):
+        from os import readinto as readinto
+
+    environ: dict[str, str]

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

@@ -0,0 +1,134 @@
+import sys
+from _typeshed import BytesPath, StrOrBytesPath, StrPath
+from genericpath import (
+    ALLOW_MISSING as ALLOW_MISSING,
+    _AllowMissingType,
+    commonprefix as commonprefix,
+    exists as exists,
+    getatime as getatime,
+    getctime as getctime,
+    getmtime as getmtime,
+    getsize as getsize,
+    isdir as isdir,
+    isfile as isfile,
+    samefile as samefile,
+    sameopenfile as sameopenfile,
+    samestat as samestat,
+)
+from os import PathLike
+
+# Re-export common definitions from posixpath to reduce duplication
+from posixpath import (
+    abspath as abspath,
+    basename as basename,
+    commonpath as commonpath,
+    curdir as curdir,
+    defpath as defpath,
+    devnull as devnull,
+    dirname as dirname,
+    expanduser as expanduser,
+    expandvars as expandvars,
+    extsep as extsep,
+    isabs as isabs,
+    islink as islink,
+    ismount as ismount,
+    lexists as lexists,
+    normcase as normcase,
+    normpath as normpath,
+    pardir as pardir,
+    pathsep as pathsep,
+    relpath as relpath,
+    sep as sep,
+    split as split,
+    splitdrive as splitdrive,
+    splitext as splitext,
+    supports_unicode_filenames as supports_unicode_filenames,
+)
+from typing import AnyStr, overload
+from typing_extensions import LiteralString
+
+if sys.version_info >= (3, 12):
+    from posixpath import isjunction as isjunction, splitroot as splitroot
+if sys.version_info >= (3, 13):
+    from genericpath import isdevdrive as isdevdrive
+if sys.version_info >= (3, 15):
+    from genericpath import ALL_BUT_LAST as ALL_BUT_LAST
+
+__all__ = [
+    "normcase",
+    "isabs",
+    "join",
+    "splitdrive",
+    "split",
+    "splitext",
+    "basename",
+    "dirname",
+    "commonprefix",
+    "getsize",
+    "getmtime",
+    "getatime",
+    "getctime",
+    "islink",
+    "exists",
+    "lexists",
+    "isdir",
+    "isfile",
+    "ismount",
+    "expanduser",
+    "expandvars",
+    "normpath",
+    "abspath",
+    "curdir",
+    "pardir",
+    "sep",
+    "pathsep",
+    "defpath",
+    "altsep",
+    "extsep",
+    "devnull",
+    "realpath",
+    "supports_unicode_filenames",
+    "relpath",
+    "samefile",
+    "sameopenfile",
+    "samestat",
+    "commonpath",
+    "ALLOW_MISSING",
+]
+if sys.version_info >= (3, 12):
+    __all__ += ["isjunction", "splitroot"]
+if sys.version_info >= (3, 13):
+    __all__ += ["isdevdrive", "isreserved"]
+if sys.version_info >= (3, 15):
+    __all__ += ["ALL_BUT_LAST"]
+
+altsep: LiteralString
+
+# First parameter is not actually pos-only,
+# but must be defined as pos-only in the stub or cross-platform code doesn't type-check,
+# as the parameter name is different in posixpath.join()
+@overload
+def join(path: LiteralString, /, *paths: LiteralString) -> LiteralString: ...
+@overload
+def join(path: StrPath, /, *paths: StrPath) -> str: ...
+@overload
+def join(path: BytesPath, /, *paths: BytesPath) -> bytes: ...
+
+if sys.version_info >= (3, 15):
+    @overload
+    def realpath(path: PathLike[AnyStr], /, *, strict: bool | _AllowMissingType = False) -> AnyStr: ...
+    @overload
+    def realpath(path: AnyStr, /, *, strict: bool | _AllowMissingType = False) -> AnyStr: ...
+
+else:
+    if sys.platform == "win32":
+        @overload
+        def realpath(path: PathLike[AnyStr], *, strict: bool | _AllowMissingType = False) -> AnyStr: ...
+        @overload
+        def realpath(path: AnyStr, *, strict: bool | _AllowMissingType = False) -> AnyStr: ...
+
+    else:
+        realpath = abspath
+
+if sys.version_info >= (3, 13):
+    def isreserved(path: StrOrBytesPath) -> bool: ...

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

@@ -0,0 +1,6 @@
+from typing_extensions import deprecated
+
+@deprecated("The `nturl2path` module is deprecated since Python 3.14.")
+def url2pathname(url: str) -> str: ...
+@deprecated("The `nturl2path` module is deprecated since Python 3.14.")
+def pathname2url(p: str) -> str: ...

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

@@ -0,0 +1,220 @@
+# Note: these stubs are incomplete. The more complex type
+# signatures are currently omitted.
+#
+# Use _ComplexLike, _RealLike and _IntegralLike for return types in this module
+# rather than `numbers.Complex`, `numbers.Real` and `numbers.Integral`,
+# to avoid an excessive number of `type: ignore`s in subclasses of these ABCs
+# (since type checkers don't see `complex` as a subtype of `numbers.Complex`,
+# nor `float` as a subtype of `numbers.Real`, etc.)
+
+from abc import ABCMeta, abstractmethod
+from typing import ClassVar, Literal, Protocol, overload, type_check_only
+
+__all__ = ["Number", "Complex", "Real", "Rational", "Integral"]
+
+############################
+# Protocols for return types
+############################
+
+# `_ComplexLike` is a structural-typing approximation
+# of the `Complex` ABC, which is not (and cannot be) a protocol
+#
+# NOTE: We can't include `__complex__` here,
+# as we want `int` to be seen as a subtype of `_ComplexLike`,
+# and `int.__complex__` does not exist :(
+@type_check_only
+class _ComplexLike(Protocol):
+    def __neg__(self) -> _ComplexLike: ...
+    def __pos__(self) -> _ComplexLike: ...
+    def __abs__(self) -> _RealLike: ...
+
+# _RealLike is a structural-typing approximation
+# of the `Real` ABC, which is not (and cannot be) a protocol
+@type_check_only
+class _RealLike(_ComplexLike, Protocol):
+    def __trunc__(self) -> _IntegralLike: ...
+    def __floor__(self) -> _IntegralLike: ...
+    def __ceil__(self) -> _IntegralLike: ...
+    def __float__(self) -> float: ...
+    # Overridden from `_ComplexLike`
+    # for a more precise return type:
+    def __neg__(self) -> _RealLike: ...
+    def __pos__(self) -> _RealLike: ...
+
+# _IntegralLike is a structural-typing approximation
+# of the `Integral` ABC, which is not (and cannot be) a protocol
+@type_check_only
+class _IntegralLike(_RealLike, Protocol):
+    def __invert__(self) -> _IntegralLike: ...
+    def __int__(self) -> int: ...
+    def __index__(self) -> int: ...
+    # Overridden from `_ComplexLike`
+    # for a more precise return type:
+    def __abs__(self) -> _IntegralLike: ...
+    # Overridden from `RealLike`
+    # for a more precise return type:
+    def __neg__(self) -> _IntegralLike: ...
+    def __pos__(self) -> _IntegralLike: ...
+
+#################
+# Module "proper"
+#################
+
+class Number(metaclass=ABCMeta):
+    __slots__ = ()
+    @abstractmethod
+    def __hash__(self) -> int: ...
+
+# See comment at the top of the file
+# for why some of these return types are purposefully vague
+class Complex(Number, _ComplexLike):
+    __slots__ = ()
+    @abstractmethod
+    def __complex__(self) -> complex: ...
+    def __bool__(self) -> bool: ...
+    @property
+    @abstractmethod
+    def real(self) -> _RealLike: ...
+    @property
+    @abstractmethod
+    def imag(self) -> _RealLike: ...
+    @abstractmethod
+    def __add__(self, other) -> _ComplexLike: ...
+    @abstractmethod
+    def __radd__(self, other) -> _ComplexLike: ...
+    @abstractmethod
+    def __neg__(self) -> _ComplexLike: ...
+    @abstractmethod
+    def __pos__(self) -> _ComplexLike: ...
+    def __sub__(self, other) -> _ComplexLike: ...
+    def __rsub__(self, other) -> _ComplexLike: ...
+    @abstractmethod
+    def __mul__(self, other) -> _ComplexLike: ...
+    @abstractmethod
+    def __rmul__(self, other) -> _ComplexLike: ...
+    @abstractmethod
+    def __truediv__(self, other) -> _ComplexLike: ...
+    @abstractmethod
+    def __rtruediv__(self, other) -> _ComplexLike: ...
+    @abstractmethod
+    def __pow__(self, exponent) -> _ComplexLike: ...
+    @abstractmethod
+    def __rpow__(self, base) -> _ComplexLike: ...
+    @abstractmethod
+    def __abs__(self) -> _RealLike: ...
+    @abstractmethod
+    def conjugate(self) -> _ComplexLike: ...
+    @abstractmethod
+    def __eq__(self, other: object) -> bool: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+
+# See comment at the top of the file
+# for why some of these return types are purposefully vague
+class Real(Complex, _RealLike):
+    __slots__ = ()
+    @abstractmethod
+    def __float__(self) -> float: ...
+    @abstractmethod
+    def __trunc__(self) -> _IntegralLike: ...
+    @abstractmethod
+    def __floor__(self) -> _IntegralLike: ...
+    @abstractmethod
+    def __ceil__(self) -> _IntegralLike: ...
+
+    @abstractmethod
+    @overload
+    def __round__(self, ndigits: None = None) -> _IntegralLike: ...
+    @abstractmethod
+    @overload
+    def __round__(self, ndigits: int) -> _RealLike: ...
+
+    def __divmod__(self, other) -> tuple[_RealLike, _RealLike]: ...
+    def __rdivmod__(self, other) -> tuple[_RealLike, _RealLike]: ...
+    @abstractmethod
+    def __floordiv__(self, other) -> _RealLike: ...
+    @abstractmethod
+    def __rfloordiv__(self, other) -> _RealLike: ...
+    @abstractmethod
+    def __mod__(self, other) -> _RealLike: ...
+    @abstractmethod
+    def __rmod__(self, other) -> _RealLike: ...
+    @abstractmethod
+    def __lt__(self, other) -> bool: ...
+    @abstractmethod
+    def __le__(self, other) -> bool: ...
+    def __complex__(self) -> complex: ...
+    @property
+    def real(self) -> _RealLike: ...
+    @property
+    def imag(self) -> Literal[0]: ...
+    def conjugate(self) -> _RealLike: ...
+    # Not actually overridden at runtime,
+    # but we override these in the stub to give them more precise return types:
+    @abstractmethod
+    def __pos__(self) -> _RealLike: ...
+    @abstractmethod
+    def __neg__(self) -> _RealLike: ...
+
+# See comment at the top of the file
+# for why some of these return types are purposefully vague
+class Rational(Real):
+    __slots__ = ()
+    @property
+    @abstractmethod
+    def numerator(self) -> _IntegralLike: ...
+    @property
+    @abstractmethod
+    def denominator(self) -> _IntegralLike: ...
+    def __float__(self) -> float: ...
+
+# See comment at the top of the file
+# for why some of these return types are purposefully vague
+class Integral(Rational, _IntegralLike):
+    __slots__ = ()
+    @abstractmethod
+    def __int__(self) -> int: ...
+    def __index__(self) -> int: ...
+    @abstractmethod
+    def __pow__(self, exponent, modulus=None) -> _IntegralLike: ...
+    @abstractmethod
+    def __lshift__(self, other) -> _IntegralLike: ...
+    @abstractmethod
+    def __rlshift__(self, other) -> _IntegralLike: ...
+    @abstractmethod
+    def __rshift__(self, other) -> _IntegralLike: ...
+    @abstractmethod
+    def __rrshift__(self, other) -> _IntegralLike: ...
+    @abstractmethod
+    def __and__(self, other) -> _IntegralLike: ...
+    @abstractmethod
+    def __rand__(self, other) -> _IntegralLike: ...
+    @abstractmethod
+    def __xor__(self, other) -> _IntegralLike: ...
+    @abstractmethod
+    def __rxor__(self, other) -> _IntegralLike: ...
+    @abstractmethod
+    def __or__(self, other) -> _IntegralLike: ...
+    @abstractmethod
+    def __ror__(self, other) -> _IntegralLike: ...
+    @abstractmethod
+    def __invert__(self) -> _IntegralLike: ...
+    def __float__(self) -> float: ...
+    @property
+    def numerator(self) -> _IntegralLike: ...
+    @property
+    def denominator(self) -> Literal[1]: ...
+    # Not actually overridden at runtime,
+    # but we override these in the stub to give them more precise return types:
+    @abstractmethod
+    def __pos__(self) -> _IntegralLike: ...
+    @abstractmethod
+    def __neg__(self) -> _IntegralLike: ...
+    @abstractmethod
+    def __abs__(self) -> _IntegralLike: ...
+
+    @abstractmethod
+    @overload
+    def __round__(self, ndigits: None = None) -> _IntegralLike: ...
+    @abstractmethod
+    @overload
+    def __round__(self, ndigits: int) -> _IntegralLike: ...

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

@@ -0,0 +1,53 @@
+import sys
+from typing import Final, Literal
+
+if sys.version_info >= (3, 15):
+    from builtins import frozendict
+
+__all__ = [
+    "cmp_op",
+    "hasconst",
+    "hasname",
+    "hasjrel",
+    "hasjabs",
+    "haslocal",
+    "hascompare",
+    "hasfree",
+    "opname",
+    "opmap",
+    "HAVE_ARGUMENT",
+    "EXTENDED_ARG",
+    "stack_effect",
+]
+if sys.version_info >= (3, 12):
+    __all__ += ["hasarg", "hasexc"]
+else:
+    __all__ += ["hasnargs"]
+if sys.version_info >= (3, 13):
+    __all__ += ["hasjump"]
+
+cmp_op: tuple[Literal["<"], Literal["<="], Literal["=="], Literal["!="], Literal[">"], Literal[">="]]
+hasconst: Final[list[int]]
+hasname: Final[list[int]]
+hasjrel: Final[list[int]]
+hasjabs: Final[list[int]]
+haslocal: Final[list[int]]
+hascompare: Final[list[int]]
+hasfree: Final[list[int]]
+if sys.version_info >= (3, 12):
+    hasarg: Final[list[int]]
+    hasexc: Final[list[int]]
+else:
+    hasnargs: Final[list[int]]
+if sys.version_info >= (3, 13):
+    hasjump: Final[list[int]]
+opname: Final[list[str]]
+
+if sys.version_info >= (3, 15):
+    opmap: Final[frozendict[str, int]]
+else:
+    opmap: Final[dict[str, int]]
+HAVE_ARGUMENT: Final[int]
+EXTENDED_ARG: Final[int]
+
+def stack_effect(opcode: int, oparg: int | None = None, /, *, jump: bool | None = None) -> int: ...