layermap 0.1.0

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

@@ -0,0 +1,157 @@
+import sys
+from _typeshed import FileDescriptorLike, ReadOnlyBuffer, WriteableBuffer
+from typing import Any, Final, Literal, overload
+from typing_extensions import Buffer
+
+if sys.platform != "win32":
+    FASYNC: Final[int]
+    FD_CLOEXEC: Final[int]
+    F_DUPFD: Final[int]
+    F_DUPFD_CLOEXEC: Final[int]
+    F_GETFD: Final[int]
+    F_GETFL: Final[int]
+    F_GETLK: Final[int]
+    F_GETOWN: Final[int]
+    F_RDLCK: Final[int]
+    F_SETFD: Final[int]
+    F_SETFL: Final[int]
+    F_SETLK: Final[int]
+    F_SETLKW: Final[int]
+    F_SETOWN: Final[int]
+    F_UNLCK: Final[int]
+    F_WRLCK: Final[int]
+
+    F_GETLEASE: Final[int]
+    F_SETLEASE: Final[int]
+    if sys.platform == "darwin":
+        F_FULLFSYNC: Final[int]
+        F_NOCACHE: Final[int]
+        F_GETPATH: Final[int]
+    if sys.platform == "linux":
+        F_SETLKW64: Final[int]
+        F_SETSIG: Final[int]
+        F_SHLCK: Final[int]
+        F_SETLK64: Final[int]
+        F_GETSIG: Final[int]
+        F_NOTIFY: Final[int]
+        F_EXLCK: Final[int]
+        F_GETLK64: Final[int]
+        F_ADD_SEALS: Final[int]
+        F_GET_SEALS: Final[int]
+        F_SEAL_GROW: Final[int]
+        F_SEAL_SEAL: Final[int]
+        F_SEAL_SHRINK: Final[int]
+        F_SEAL_WRITE: Final[int]
+        F_OFD_GETLK: Final[int]
+        F_OFD_SETLK: Final[int]
+        F_OFD_SETLKW: Final[int]
+        F_GETPIPE_SZ: Final[int]
+        F_SETPIPE_SZ: Final[int]
+        DN_ACCESS: Final[int]
+        DN_ATTRIB: Final[int]
+        DN_CREATE: Final[int]
+        DN_DELETE: Final[int]
+        DN_MODIFY: Final[int]
+        DN_MULTISHOT: Final[int]
+        DN_RENAME: Final[int]
+
+    LOCK_EX: Final[int]
+    LOCK_NB: Final[int]
+    LOCK_SH: Final[int]
+    LOCK_UN: Final[int]
+    if sys.platform == "linux":
+        LOCK_MAND: Final[int]
+        LOCK_READ: Final[int]
+        LOCK_RW: Final[int]
+        LOCK_WRITE: Final[int]
+
+    if sys.platform == "linux":
+        # Constants for the POSIX STREAMS interface. Present in glibc until 2.29 (released February 2019).
+        # Never implemented on BSD, and considered "obsolescent" starting in POSIX 2008.
+        # Probably still used on Solaris.
+        I_ATMARK: Final[int]
+        I_CANPUT: Final[int]
+        I_CKBAND: Final[int]
+        I_FDINSERT: Final[int]
+        I_FIND: Final[int]
+        I_FLUSH: Final[int]
+        I_FLUSHBAND: Final[int]
+        I_GETBAND: Final[int]
+        I_GETCLTIME: Final[int]
+        I_GETSIG: Final[int]
+        I_GRDOPT: Final[int]
+        I_GWROPT: Final[int]
+        I_LINK: Final[int]
+        I_LIST: Final[int]
+        I_LOOK: Final[int]
+        I_NREAD: Final[int]
+        I_PEEK: Final[int]
+        I_PLINK: Final[int]
+        I_POP: Final[int]
+        I_PUNLINK: Final[int]
+        I_PUSH: Final[int]
+        I_RECVFD: Final[int]
+        I_SENDFD: Final[int]
+        I_SETCLTIME: Final[int]
+        I_SETSIG: Final[int]
+        I_SRDOPT: Final[int]
+        I_STR: Final[int]
+        I_SWROPT: Final[int]
+        I_UNLINK: Final[int]
+
+    if sys.version_info >= (3, 12) and sys.platform == "linux":
+        FICLONE: Final[int]
+        FICLONERANGE: Final[int]
+
+    if sys.version_info >= (3, 13) and sys.platform == "linux":
+        F_OWNER_TID: Final = 0
+        F_OWNER_PID: Final = 1
+        F_OWNER_PGRP: Final = 2
+        F_SETOWN_EX: Final = 15
+        F_GETOWN_EX: Final = 16
+        F_SEAL_FUTURE_WRITE: Final = 16
+        F_GET_RW_HINT: Final = 1035
+        F_SET_RW_HINT: Final = 1036
+        F_GET_FILE_RW_HINT: Final = 1037
+        F_SET_FILE_RW_HINT: Final = 1038
+        RWH_WRITE_LIFE_NOT_SET: Final = 0
+        RWH_WRITE_LIFE_NONE: Final = 1
+        RWH_WRITE_LIFE_SHORT: Final = 2
+        RWH_WRITE_LIFE_MEDIUM: Final = 3
+        RWH_WRITE_LIFE_LONG: Final = 4
+        RWH_WRITE_LIFE_EXTREME: Final = 5
+
+    if sys.version_info >= (3, 11) and sys.platform == "darwin":
+        F_OFD_SETLK: Final = 90
+        F_OFD_SETLKW: Final = 91
+        F_OFD_GETLK: Final = 92
+
+    if sys.version_info >= (3, 13) and sys.platform != "linux":
+        # OSx and NetBSD
+        F_GETNOSIGPIPE: Final[int]
+        F_SETNOSIGPIPE: Final[int]
+        # OSx and FreeBSD
+        F_RDAHEAD: Final[int]
+
+    @overload
+    def fcntl(fd: FileDescriptorLike, cmd: int, arg: int = 0, /) -> int: ...
+    @overload
+    def fcntl(fd: FileDescriptorLike, cmd: int, arg: str | ReadOnlyBuffer, /) -> bytes: ...
+
+    # If arg is an int, return int
+    @overload
+    def ioctl(fd: FileDescriptorLike, request: int, arg: int = 0, mutate_flag: bool = True, /) -> int: ...
+    # The return type works as follows:
+    # - If arg is a read-write buffer, return int if mutate_flag is True, otherwise bytes
+    # - If arg is a read-only buffer, return bytes (and ignore the value of mutate_flag)
+    # We can't represent that precisely as we can't distinguish between read-write and read-only
+    # buffers, so we add overloads for a few unambiguous cases and use Any for the rest.
+    @overload
+    def ioctl(fd: FileDescriptorLike, request: int, arg: bytes, mutate_flag: bool = True, /) -> bytes: ...
+    @overload
+    def ioctl(fd: FileDescriptorLike, request: int, arg: WriteableBuffer, mutate_flag: Literal[False], /) -> bytes: ...
+    @overload
+    def ioctl(fd: FileDescriptorLike, request: int, arg: Buffer, mutate_flag: bool = True, /) -> Any: ...
+
+    def flock(fd: FileDescriptorLike, operation: int, /) -> None: ...
+    def lockf(fd: FileDescriptorLike, cmd: int, len: int = 0, start: int = 0, whence: int = 0, /) -> Any: ...

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

@@ -0,0 +1,65 @@
+import sys
+from _typeshed import GenericPath, StrOrBytesPath
+from collections.abc import Callable, Iterable, Sequence
+from types import GenericAlias
+from typing import Any, AnyStr, Final, Generic, Literal
+
+__all__ = ["clear_cache", "cmp", "dircmp", "cmpfiles", "DEFAULT_IGNORES"]
+
+DEFAULT_IGNORES: Final[list[str]]
+BUFSIZE: Final = 8192
+
+def cmp(f1: StrOrBytesPath, f2: StrOrBytesPath, shallow: bool | Literal[0, 1] = True) -> bool: ...
+def cmpfiles(
+    a: GenericPath[AnyStr], b: GenericPath[AnyStr], common: Iterable[GenericPath[AnyStr]], shallow: bool | Literal[0, 1] = True
+) -> tuple[list[AnyStr], list[AnyStr], list[AnyStr]]: ...
+
+class dircmp(Generic[AnyStr]):
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            a: GenericPath[AnyStr],
+            b: GenericPath[AnyStr],
+            ignore: Sequence[AnyStr] | None = None,
+            hide: Sequence[AnyStr] | None = None,
+            *,
+            shallow: bool = True,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            a: GenericPath[AnyStr],
+            b: GenericPath[AnyStr],
+            ignore: Sequence[AnyStr] | None = None,
+            hide: Sequence[AnyStr] | None = None,
+        ) -> None: ...
+    left: AnyStr
+    right: AnyStr
+    hide: Sequence[AnyStr]
+    ignore: Sequence[AnyStr]
+    # These properties are created at runtime by __getattr__
+    subdirs: dict[AnyStr, dircmp[AnyStr]]
+    same_files: list[AnyStr]
+    diff_files: list[AnyStr]
+    funny_files: list[AnyStr]
+    common_dirs: list[AnyStr]
+    common_files: list[AnyStr]
+    common_funny: list[AnyStr]
+    common: list[AnyStr]
+    left_only: list[AnyStr]
+    right_only: list[AnyStr]
+    left_list: list[AnyStr]
+    right_list: list[AnyStr]
+    def report(self) -> None: ...
+    def report_partial_closure(self) -> None: ...
+    def report_full_closure(self) -> None: ...
+    methodmap: dict[str, Callable[[], None]]
+    def phase0(self) -> None: ...
+    def phase1(self) -> None: ...
+    def phase2(self) -> None: ...
+    def phase3(self) -> None: ...
+    def phase4(self) -> None: ...
+    def phase4_closure(self) -> None: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+def clear_cache() -> None: ...

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

@@ -0,0 +1,141 @@
+import sys
+from _typeshed import AnyStr_co, StrOrBytesPath
+from collections.abc import Callable, Iterable
+from types import GenericAlias, TracebackType
+from typing import IO, Any, AnyStr, Generic, Literal, Protocol, TypeAlias, overload, type_check_only
+from typing_extensions import Self, deprecated
+
+__all__ = [
+    "input",
+    "close",
+    "nextfile",
+    "filename",
+    "lineno",
+    "filelineno",
+    "fileno",
+    "isfirstline",
+    "isstdin",
+    "FileInput",
+    "hook_compressed",
+    "hook_encoded",
+]
+
+if sys.version_info >= (3, 11):
+    _TextMode: TypeAlias = Literal["r"]
+else:
+    _TextMode: TypeAlias = Literal["r", "rU", "U"]
+
+@type_check_only
+class _HasReadlineAndFileno(Protocol[AnyStr_co]):
+    def readline(self) -> AnyStr_co: ...
+    def fileno(self) -> int: ...
+
+# encoding and errors are added
+@overload
+def input(
+    files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
+    inplace: bool = False,
+    backup: str = "",
+    *,
+    mode: _TextMode = "r",
+    openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[str]] | None = None,
+    encoding: str | None = None,
+    errors: str | None = None,
+) -> FileInput[str]: ...
+@overload
+def input(
+    files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
+    inplace: bool = False,
+    backup: str = "",
+    *,
+    mode: Literal["rb"],
+    openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[bytes]] | None = None,
+    encoding: None = None,
+    errors: None = None,
+) -> FileInput[bytes]: ...
+@overload
+def input(
+    files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
+    inplace: bool = False,
+    backup: str = "",
+    *,
+    mode: str,
+    openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[Any]] | None = None,
+    encoding: str | None = None,
+    errors: str | None = None,
+) -> FileInput[Any]: ...
+
+def close() -> None: ...
+def nextfile() -> None: ...
+def filename() -> str: ...
+def lineno() -> int: ...
+def filelineno() -> int: ...
+def fileno() -> int: ...
+def isfirstline() -> bool: ...
+def isstdin() -> bool: ...
+
+class FileInput(Generic[AnyStr]):
+    # encoding and errors are added
+    @overload
+    def __init__(
+        self: FileInput[str],
+        files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
+        inplace: bool = False,
+        backup: str = "",
+        *,
+        mode: _TextMode = "r",
+        openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[str]] | None = None,
+        encoding: str | None = None,
+        errors: str | None = None,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self: FileInput[bytes],
+        files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
+        inplace: bool = False,
+        backup: str = "",
+        *,
+        mode: Literal["rb"],
+        openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[bytes]] | None = None,
+        encoding: None = None,
+        errors: None = None,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self: FileInput[Any],
+        files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
+        inplace: bool = False,
+        backup: str = "",
+        *,
+        mode: str,
+        openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[Any]] | None = None,
+        encoding: str | None = None,
+        errors: str | None = None,
+    ) -> None: ...
+
+    def __del__(self) -> None: ...
+    def close(self) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
+    ) -> None: ...
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> AnyStr: ...
+    if sys.version_info < (3, 11):
+        def __getitem__(self, i: int) -> AnyStr: ...
+
+    def nextfile(self) -> None: ...
+    def readline(self) -> AnyStr: ...
+    def filename(self) -> str: ...
+    def lineno(self) -> int: ...
+    def filelineno(self) -> int: ...
+    def fileno(self) -> int: ...
+    def isfirstline(self) -> bool: ...
+    def isstdin(self) -> bool: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+def hook_compressed(
+    filename: StrOrBytesPath, mode: str, *, encoding: str | None = None, errors: str | None = None
+) -> IO[Any]: ...
+@deprecated("Deprecated since Python 3.10. Use `fileinput.input` or `fileinput.FileInput` instead.")
+def hook_encoded(encoding: str, errors: str | None = None) -> Callable[[StrOrBytesPath, str], IO[Any]]: ...

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

@@ -0,0 +1,15 @@
+import sys
+from collections.abc import Iterable
+from typing import AnyStr
+
+__all__ = ["filter", "fnmatch", "fnmatchcase", "translate"]
+if sys.version_info >= (3, 14):
+    __all__ += ["filterfalse"]
+
+def fnmatch(name: AnyStr, pat: AnyStr) -> bool: ...
+def fnmatchcase(name: AnyStr, pat: AnyStr) -> bool: ...
+def filter(names: Iterable[AnyStr], pat: AnyStr) -> list[AnyStr]: ...
+def translate(pat: str) -> str: ...
+
+if sys.version_info >= (3, 14):
+    def filterfalse(names: Iterable[AnyStr], pat: AnyStr) -> list[AnyStr]: ...

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

@@ -0,0 +1,185 @@
+import sys
+from collections.abc import Callable
+from decimal import Decimal
+from numbers import Rational, Real
+from typing import Any, Literal, Protocol, SupportsIndex, TypeAlias, overload, type_check_only
+from typing_extensions import Self
+
+_ComparableNum: TypeAlias = int | float | Decimal | Real
+
+__all__ = ["Fraction"]
+
+@type_check_only
+class _ConvertibleToIntegerRatio(Protocol):
+    def as_integer_ratio(self) -> tuple[int | Rational, int | Rational]: ...
+
+class Fraction(Rational):
+    __slots__ = ("_numerator", "_denominator")
+
+    @overload
+    def __new__(cls, numerator: int | Rational = 0, denominator: int | Rational | None = None) -> Self: ...
+    @overload
+    def __new__(cls, numerator: float | Decimal | str) -> Self: ...
+    if sys.version_info >= (3, 14):
+        @overload
+        def __new__(cls, numerator: _ConvertibleToIntegerRatio) -> Self: ...
+
+    @classmethod
+    def from_float(cls, f: float) -> Self: ...
+    @classmethod
+    def from_decimal(cls, dec: Decimal) -> Self: ...
+    def limit_denominator(self, max_denominator: int = 1000000) -> Fraction: ...
+    def as_integer_ratio(self) -> tuple[int, int]: ...
+    if sys.version_info >= (3, 12):
+        def is_integer(self) -> bool: ...
+
+    @property
+    def numerator(a) -> int: ...
+    @property
+    def denominator(a) -> int: ...
+
+    @overload
+    def __add__(a, b: int | Fraction) -> Fraction: ...
+    @overload
+    def __add__(a, b: float) -> float: ...
+    @overload
+    def __add__(a, b: complex) -> complex: ...
+
+    @overload
+    def __radd__(b, a: int | Fraction) -> Fraction: ...
+    @overload
+    def __radd__(b, a: float) -> float: ...
+    @overload
+    def __radd__(b, a: complex) -> complex: ...
+
+    @overload
+    def __sub__(a, b: int | Fraction) -> Fraction: ...
+    @overload
+    def __sub__(a, b: float) -> float: ...
+    @overload
+    def __sub__(a, b: complex) -> complex: ...
+
+    @overload
+    def __rsub__(b, a: int | Fraction) -> Fraction: ...
+    @overload
+    def __rsub__(b, a: float) -> float: ...
+    @overload
+    def __rsub__(b, a: complex) -> complex: ...
+
+    @overload
+    def __mul__(a, b: int | Fraction) -> Fraction: ...
+    @overload
+    def __mul__(a, b: float) -> float: ...
+    @overload
+    def __mul__(a, b: complex) -> complex: ...
+
+    @overload
+    def __rmul__(b, a: int | Fraction) -> Fraction: ...
+    @overload
+    def __rmul__(b, a: float) -> float: ...
+    @overload
+    def __rmul__(b, a: complex) -> complex: ...
+
+    @overload
+    def __truediv__(a, b: int | Fraction) -> Fraction: ...
+    @overload
+    def __truediv__(a, b: float) -> float: ...
+    @overload
+    def __truediv__(a, b: complex) -> complex: ...
+
+    @overload
+    def __rtruediv__(b, a: int | Fraction) -> Fraction: ...
+    @overload
+    def __rtruediv__(b, a: float) -> float: ...
+    @overload
+    def __rtruediv__(b, a: complex) -> complex: ...
+
+    @overload
+    def __floordiv__(a, b: int | Fraction) -> int: ...
+    @overload
+    def __floordiv__(a, b: float) -> float: ...
+
+    @overload
+    def __rfloordiv__(b, a: int | Fraction) -> int: ...
+    @overload
+    def __rfloordiv__(b, a: float) -> float: ...
+
+    @overload
+    def __mod__(a, b: int | Fraction) -> Fraction: ...
+    @overload
+    def __mod__(a, b: float) -> float: ...
+
+    @overload
+    def __rmod__(b, a: int | Fraction) -> Fraction: ...
+    @overload
+    def __rmod__(b, a: float) -> float: ...
+
+    @overload
+    def __divmod__(a, b: int | Fraction) -> tuple[int, Fraction]: ...
+    @overload
+    def __divmod__(a, b: float) -> tuple[float, Fraction]: ...
+
+    @overload
+    def __rdivmod__(a, b: int | Fraction) -> tuple[int, Fraction]: ...
+    @overload
+    def __rdivmod__(a, b: float) -> tuple[float, Fraction]: ...
+
+    if sys.version_info >= (3, 14):
+        @overload
+        def __pow__(a, b: int, modulo: None = None) -> Fraction: ...
+        @overload
+        def __pow__(a, b: float | Fraction, modulo: None = None) -> float: ...
+        @overload
+        def __pow__(a, b: complex, modulo: None = None) -> complex: ...
+    else:
+        @overload
+        def __pow__(a, b: int) -> Fraction: ...
+        @overload
+        def __pow__(a, b: float | Fraction) -> float: ...
+        @overload
+        def __pow__(a, b: complex) -> complex: ...
+
+    if sys.version_info >= (3, 14):
+        @overload
+        def __rpow__(b, a: float | Fraction, modulo: None = None) -> float: ...
+        @overload
+        def __rpow__(b, a: complex, modulo: None = None) -> complex: ...
+    else:
+        @overload
+        def __rpow__(b, a: float | Fraction) -> float: ...
+        @overload
+        def __rpow__(b, a: complex) -> complex: ...
+
+    def __pos__(a) -> Fraction: ...
+    def __neg__(a) -> Fraction: ...
+    def __abs__(a) -> Fraction: ...
+    def __trunc__(a) -> int: ...
+    def __floor__(a) -> int: ...
+    def __ceil__(a) -> int: ...
+
+    @overload
+    def __round__(self, ndigits: None = None) -> int: ...
+    @overload
+    def __round__(self, ndigits: int) -> Fraction: ...
+
+    def __hash__(self) -> int: ...  # type: ignore[override]
+    def __eq__(a, b: object) -> bool: ...
+    def __lt__(a, b: _ComparableNum) -> bool: ...
+    def __gt__(a, b: _ComparableNum) -> bool: ...
+    def __le__(a, b: _ComparableNum) -> bool: ...
+    def __ge__(a, b: _ComparableNum) -> bool: ...
+    def __bool__(a) -> bool: ...
+    def __copy__(self) -> Self: ...
+    def __deepcopy__(self, memo: Any) -> Self: ...
+    if sys.version_info >= (3, 11):
+        def __int__(a, _index: Callable[[SupportsIndex], int] = ...) -> int: ...
+    # Not actually defined within fractions.py, but provides more useful
+    # overrides
+    @property
+    def real(self) -> Fraction: ...
+    @property
+    def imag(self) -> Literal[0]: ...
+    def conjugate(self) -> Fraction: ...
+    if sys.version_info >= (3, 14):
+        @classmethod
+        def from_number(cls, number: float | Rational | _ConvertibleToIntegerRatio) -> Self: ...