layermap 0.1.0

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

@@ -0,0 +1,135 @@
+import _random
+import sys
+from _typeshed import SupportsLenAndGetItem
+from collections.abc import Callable, Iterable, MutableSequence, Sequence, Set as AbstractSet
+from fractions import Fraction
+from typing import Any, ClassVar, NoReturn, TypeVar, overload
+from typing_extensions import deprecated
+
+__all__ = [
+    "Random",
+    "seed",
+    "random",
+    "uniform",
+    "randint",
+    "choice",
+    "sample",
+    "randrange",
+    "shuffle",
+    "normalvariate",
+    "lognormvariate",
+    "expovariate",
+    "vonmisesvariate",
+    "gammavariate",
+    "triangular",
+    "gauss",
+    "betavariate",
+    "paretovariate",
+    "weibullvariate",
+    "getstate",
+    "setstate",
+    "getrandbits",
+    "choices",
+    "SystemRandom",
+    "randbytes",
+]
+
+if sys.version_info >= (3, 12):
+    __all__ += ["binomialvariate"]
+
+_T = TypeVar("_T")
+
+class Random(_random.Random):
+    VERSION: ClassVar[int]
+    def __init__(self, x: int | float | str | bytes | bytearray | None = None) -> None: ...  # noqa: Y041
+    # Using other `seed` types is deprecated since 3.9 and removed in 3.11
+    # Ignore Y041, since random.seed doesn't treat int like a float subtype. Having an explicit
+    # int better documents conventional usage of random.seed.
+
+    def seed(self, a: int | float | str | bytes | bytearray | None = None, version: int = 2) -> None: ...  # type: ignore[override]  # noqa: Y041
+    def getstate(self) -> tuple[Any, ...]: ...
+    def setstate(self, state: tuple[Any, ...]) -> None: ...
+    def randrange(self, start: int, stop: int | None = None, step: int = 1) -> int: ...
+    def randint(self, a: int, b: int) -> int: ...
+    def randbytes(self, n: int) -> bytes: ...
+    def choice(self, seq: SupportsLenAndGetItem[_T]) -> _T: ...
+    def choices(
+        self,
+        population: SupportsLenAndGetItem[_T],
+        weights: Sequence[float | Fraction] | None = None,
+        *,
+        cum_weights: Sequence[float | Fraction] | None = None,
+        k: int = 1,
+    ) -> list[_T]: ...
+    if sys.version_info >= (3, 11):
+        def shuffle(self, x: MutableSequence[Any]) -> None: ...
+    else:
+        @overload
+        def shuffle(self, x: MutableSequence[Any]) -> None: ...
+        @overload
+        @deprecated("The `random` parameter is deprecated since Python 3.9; removed in Python 3.11.")
+        def shuffle(self, x: MutableSequence[Any], random: Callable[[], float] | None = None) -> None: ...
+
+    if sys.version_info >= (3, 11):
+        def sample(self, population: Sequence[_T], k: int, *, counts: Iterable[int] | None = None) -> list[_T]: ...
+    else:
+        def sample(
+            self, population: Sequence[_T] | AbstractSet[_T], k: int, *, counts: Iterable[int] | None = None
+        ) -> list[_T]: ...
+
+    def uniform(self, a: float, b: float) -> float: ...
+    def triangular(self, low: float = 0.0, high: float = 1.0, mode: float | None = None) -> float: ...
+    if sys.version_info >= (3, 12):
+        def binomialvariate(self, n: int = 1, p: float = 0.5) -> int: ...
+
+    def betavariate(self, alpha: float, beta: float) -> float: ...
+    if sys.version_info >= (3, 12):
+        def expovariate(self, lambd: float = 1.0) -> float: ...
+    else:
+        def expovariate(self, lambd: float) -> float: ...
+
+    def gammavariate(self, alpha: float, beta: float) -> float: ...
+    if sys.version_info >= (3, 11):
+        def gauss(self, mu: float = 0.0, sigma: float = 1.0) -> float: ...
+        def normalvariate(self, mu: float = 0.0, sigma: float = 1.0) -> float: ...
+    else:
+        def gauss(self, mu: float, sigma: float) -> float: ...
+        def normalvariate(self, mu: float, sigma: float) -> float: ...
+
+    def lognormvariate(self, mu: float, sigma: float) -> float: ...
+    def vonmisesvariate(self, mu: float, kappa: float) -> float: ...
+    def paretovariate(self, alpha: float) -> float: ...
+    def weibullvariate(self, alpha: float, beta: float) -> float: ...
+
+# SystemRandom is not implemented for all OS's; good on Windows & Linux
+class SystemRandom(Random):
+    def getrandbits(self, k: int) -> int: ...  # k can be passed by keyword
+    def getstate(self, *args: Any, **kwds: Any) -> NoReturn: ...
+    def setstate(self, *args: Any, **kwds: Any) -> NoReturn: ...
+
+_inst: Random
+seed = _inst.seed
+random = _inst.random
+uniform = _inst.uniform
+triangular = _inst.triangular
+randint = _inst.randint
+choice = _inst.choice
+randrange = _inst.randrange
+sample = _inst.sample
+shuffle = _inst.shuffle
+choices = _inst.choices
+normalvariate = _inst.normalvariate
+lognormvariate = _inst.lognormvariate
+expovariate = _inst.expovariate
+vonmisesvariate = _inst.vonmisesvariate
+gammavariate = _inst.gammavariate
+gauss = _inst.gauss
+if sys.version_info >= (3, 12):
+    binomialvariate = _inst.binomialvariate
+betavariate = _inst.betavariate
+paretovariate = _inst.paretovariate
+weibullvariate = _inst.weibullvariate
+getstate = _inst.getstate
+setstate = _inst.setstate
+getrandbits = _inst.getrandbits
+randbytes = _inst.randbytes

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

@@ -0,0 +1,346 @@
+import enum
+import sys
+from _typeshed import MaybeNone, ReadableBuffer
+from collections.abc import Callable, Iterator, Mapping
+from types import GenericAlias
+from typing import Any, AnyStr, Final, Generic, Literal, TypeAlias, TypeVar, final, overload
+from typing_extensions import deprecated
+
+__all__ = [
+    "match",
+    "fullmatch",
+    "search",
+    "sub",
+    "subn",
+    "split",
+    "findall",
+    "finditer",
+    "compile",
+    "purge",
+    "escape",
+    "error",
+    "A",
+    "I",
+    "L",
+    "M",
+    "S",
+    "X",
+    "U",
+    "ASCII",
+    "IGNORECASE",
+    "LOCALE",
+    "MULTILINE",
+    "DOTALL",
+    "VERBOSE",
+    "UNICODE",
+    "Match",
+    "Pattern",
+]
+if sys.version_info >= (3, 15):
+    __all__ += ["prefixmatch"]
+if sys.version_info < (3, 13):
+    __all__ += ["template"]
+
+if sys.version_info >= (3, 11):
+    __all__ += ["NOFLAG", "RegexFlag"]
+
+if sys.version_info >= (3, 13):
+    __all__ += ["PatternError"]
+
+_T = TypeVar("_T")
+
+# The implementation defines this in re._constants (version_info >= 3, 11) or
+# sre_constants. Typeshed has it here because its __module__ attribute is set to "re".
+class error(Exception):
+    msg: str
+    pattern: str | bytes | None
+    pos: int | None
+    lineno: int
+    colno: int
+    def __init__(self, msg: str, pattern: str | bytes | None = None, pos: int | None = None) -> None: ...
+
+if sys.version_info >= (3, 13):
+    PatternError = error
+
+@final
+class Match(Generic[AnyStr]):
+    @property
+    def pos(self) -> int: ...
+    @property
+    def endpos(self) -> int: ...
+    @property
+    def lastindex(self) -> int | None: ...
+    @property
+    def lastgroup(self) -> str | None: ...
+    @property
+    def string(self) -> AnyStr: ...
+
+    # The regular expression object whose match() or search() method produced
+    # this match instance.
+    @property
+    def re(self) -> Pattern[AnyStr]: ...
+
+    @overload
+    def expand(self: Match[str], template: str) -> str: ...
+    @overload
+    def expand(self: Match[bytes], template: ReadableBuffer) -> bytes: ...
+    @overload
+    def expand(self, template: AnyStr) -> AnyStr: ...
+
+    # group() returns "AnyStr" or "AnyStr | None", depending on the pattern.
+    @overload
+    def group(self, group: Literal[0] = 0, /) -> AnyStr: ...
+    @overload
+    def group(self, group: str | int, /) -> AnyStr | MaybeNone: ...
+    @overload
+    def group(self, group1: str | int, group2: str | int, /, *groups: str | int) -> tuple[AnyStr | MaybeNone, ...]: ...
+
+    # Each item of groups()'s return tuple is either "AnyStr" or
+    # "AnyStr | None", depending on the pattern.
+    @overload
+    def groups(self) -> tuple[AnyStr | MaybeNone, ...]: ...
+    @overload
+    def groups(self, default: _T) -> tuple[AnyStr | _T, ...]: ...
+
+    # Each value in groupdict()'s return dict is either "AnyStr" or
+    # "AnyStr | None", depending on the pattern.
+    @overload
+    def groupdict(self) -> dict[str, AnyStr | MaybeNone]: ...
+    @overload
+    def groupdict(self, default: _T) -> dict[str, AnyStr | _T]: ...
+
+    def start(self, group: int | str = 0, /) -> int: ...
+    def end(self, group: int | str = 0, /) -> int: ...
+    def span(self, group: int | str = 0, /) -> tuple[int, int]: ...
+    @property
+    def regs(self) -> tuple[tuple[int, int], ...]: ...  # undocumented
+
+    # __getitem__() returns "AnyStr" or "AnyStr | None", depending on the pattern.
+    @overload
+    def __getitem__(self, key: Literal[0], /) -> AnyStr: ...
+    @overload
+    def __getitem__(self, key: int | str, /) -> AnyStr | MaybeNone: ...
+
+    def __copy__(self) -> Match[AnyStr]: ...
+    def __deepcopy__(self, memo: Any, /) -> Match[AnyStr]: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+@final
+class Pattern(Generic[AnyStr]):
+    @property
+    def flags(self) -> int: ...
+    @property
+    def groupindex(self) -> Mapping[str, int]: ...
+    @property
+    def groups(self) -> int: ...
+    @property
+    def pattern(self) -> AnyStr: ...
+
+    @overload
+    def search(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> Match[str] | None: ...
+    @overload
+    def search(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> Match[bytes] | None: ...
+    @overload
+    def search(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> Match[AnyStr] | None: ...
+
+    @overload
+    def match(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> Match[str] | None: ...
+    @overload
+    def match(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> Match[bytes] | None: ...
+    @overload
+    def match(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> Match[AnyStr] | None: ...
+
+    if sys.version_info >= (3, 15):
+        prefixmatch = match
+
+    @overload
+    def fullmatch(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> Match[str] | None: ...
+    @overload
+    def fullmatch(
+        self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize
+    ) -> Match[bytes] | None: ...
+    @overload
+    def fullmatch(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> Match[AnyStr] | None: ...
+
+    @overload
+    def split(self: Pattern[str], string: str, maxsplit: int = 0) -> list[str | MaybeNone]: ...
+    @overload
+    def split(self: Pattern[bytes], string: ReadableBuffer, maxsplit: int = 0) -> list[bytes | MaybeNone]: ...
+    @overload
+    def split(self, string: AnyStr, maxsplit: int = 0) -> list[AnyStr | MaybeNone]: ...
+
+    # return type depends on the number of groups in the pattern
+    @overload
+    def findall(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> list[Any]: ...
+    @overload
+    def findall(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> list[Any]: ...
+    @overload
+    def findall(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> list[AnyStr]: ...
+
+    @overload
+    def finditer(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> Iterator[Match[str]]: ...
+    @overload
+    def finditer(
+        self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize
+    ) -> Iterator[Match[bytes]]: ...
+    @overload
+    def finditer(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> Iterator[Match[AnyStr]]: ...
+
+    @overload
+    def sub(self: Pattern[str], repl: str | Callable[[Match[str]], str], string: str, count: int = 0) -> str: ...
+    @overload
+    def sub(
+        self: Pattern[bytes],
+        repl: ReadableBuffer | Callable[[Match[bytes]], ReadableBuffer],
+        string: ReadableBuffer,
+        count: int = 0,
+    ) -> bytes: ...
+    @overload
+    def sub(self, repl: AnyStr | Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = 0) -> AnyStr: ...
+
+    @overload
+    def subn(self: Pattern[str], repl: str | Callable[[Match[str]], str], string: str, count: int = 0) -> tuple[str, int]: ...
+    @overload
+    def subn(
+        self: Pattern[bytes],
+        repl: ReadableBuffer | Callable[[Match[bytes]], ReadableBuffer],
+        string: ReadableBuffer,
+        count: int = 0,
+    ) -> tuple[bytes, int]: ...
+    @overload
+    def subn(self, repl: AnyStr | Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = 0) -> tuple[AnyStr, int]: ...
+
+    def __copy__(self) -> Pattern[AnyStr]: ...
+    def __deepcopy__(self, memo: Any, /) -> Pattern[AnyStr]: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+# ----- re variables and constants -----
+
+class RegexFlag(enum.IntFlag):
+    A = 256
+    ASCII = A
+    DEBUG = 128
+    I = 2
+    IGNORECASE = I
+    L = 4
+    LOCALE = L
+    M = 8
+    MULTILINE = M
+    S = 16
+    DOTALL = S
+    X = 64
+    VERBOSE = X
+    U = 32
+    UNICODE = U
+    if sys.version_info < (3, 13):
+        T = 1
+        TEMPLATE = T
+    if sys.version_info >= (3, 11):
+        NOFLAG = 0
+
+A: Final = RegexFlag.A
+ASCII: Final = RegexFlag.ASCII
+DEBUG: Final = RegexFlag.DEBUG
+I: Final = RegexFlag.I
+IGNORECASE: Final = RegexFlag.IGNORECASE
+L: Final = RegexFlag.L
+LOCALE: Final = RegexFlag.LOCALE
+M: Final = RegexFlag.M
+MULTILINE: Final = RegexFlag.MULTILINE
+S: Final = RegexFlag.S
+DOTALL: Final = RegexFlag.DOTALL
+X: Final = RegexFlag.X
+VERBOSE: Final = RegexFlag.VERBOSE
+U: Final = RegexFlag.U
+UNICODE: Final = RegexFlag.UNICODE
+if sys.version_info < (3, 13):
+    T: Final = RegexFlag.T
+    TEMPLATE: Final = RegexFlag.TEMPLATE
+if sys.version_info >= (3, 11):
+    NOFLAG: Final = RegexFlag.NOFLAG
+_FlagsType: TypeAlias = int | RegexFlag
+
+# Type-wise the compile() overloads are unnecessary, they could also be modeled using
+# unions in the parameter types. However mypy has a bug regarding TypeVar
+# constraints (https://github.com/python/mypy/issues/11880),
+# which limits us here because AnyStr is a constrained TypeVar.
+
+# pattern arguments do *not* accept arbitrary buffers such as bytearray,
+# because the pattern must be hashable.
+@overload
+def compile(pattern: AnyStr, flags: _FlagsType = 0) -> Pattern[AnyStr]: ...
+@overload
+def compile(pattern: Pattern[AnyStr], flags: _FlagsType = 0) -> Pattern[AnyStr]: ...
+
+@overload
+def search(pattern: str | Pattern[str], string: str, flags: _FlagsType = 0) -> Match[str] | None: ...
+@overload
+def search(pattern: bytes | Pattern[bytes], string: ReadableBuffer, flags: _FlagsType = 0) -> Match[bytes] | None: ...
+
+@overload
+def match(pattern: str | Pattern[str], string: str, flags: _FlagsType = 0) -> Match[str] | None: ...
+@overload
+def match(pattern: bytes | Pattern[bytes], string: ReadableBuffer, flags: _FlagsType = 0) -> Match[bytes] | None: ...
+
+if sys.version_info >= (3, 15):
+    @overload
+    def prefixmatch(pattern: str | Pattern[str], string: str, flags: _FlagsType = 0) -> Match[str] | None: ...
+    @overload
+    def prefixmatch(pattern: bytes | Pattern[bytes], string: ReadableBuffer, flags: _FlagsType = 0) -> Match[bytes] | None: ...
+
+@overload
+def fullmatch(pattern: str | Pattern[str], string: str, flags: _FlagsType = 0) -> Match[str] | None: ...
+@overload
+def fullmatch(pattern: bytes | Pattern[bytes], string: ReadableBuffer, flags: _FlagsType = 0) -> Match[bytes] | None: ...
+
+@overload
+def split(pattern: str | Pattern[str], string: str, maxsplit: int = 0, flags: _FlagsType = 0) -> list[str | MaybeNone]: ...
+@overload
+def split(
+    pattern: bytes | Pattern[bytes], string: ReadableBuffer, maxsplit: int = 0, flags: _FlagsType = 0
+) -> list[bytes | MaybeNone]: ...
+
+@overload
+def findall(pattern: str | Pattern[str], string: str, flags: _FlagsType = 0) -> list[Any]: ...
+@overload
+def findall(pattern: bytes | Pattern[bytes], string: ReadableBuffer, flags: _FlagsType = 0) -> list[Any]: ...
+
+@overload
+def finditer(pattern: str | Pattern[str], string: str, flags: _FlagsType = 0) -> Iterator[Match[str]]: ...
+@overload
+def finditer(pattern: bytes | Pattern[bytes], string: ReadableBuffer, flags: _FlagsType = 0) -> Iterator[Match[bytes]]: ...
+
+@overload
+def sub(
+    pattern: str | Pattern[str], repl: str | Callable[[Match[str]], str], string: str, count: int = 0, flags: _FlagsType = 0
+) -> str: ...
+@overload
+def sub(
+    pattern: bytes | Pattern[bytes],
+    repl: ReadableBuffer | Callable[[Match[bytes]], ReadableBuffer],
+    string: ReadableBuffer,
+    count: int = 0,
+    flags: _FlagsType = 0,
+) -> bytes: ...
+
+@overload
+def subn(
+    pattern: str | Pattern[str], repl: str | Callable[[Match[str]], str], string: str, count: int = 0, flags: _FlagsType = 0
+) -> tuple[str, int]: ...
+@overload
+def subn(
+    pattern: bytes | Pattern[bytes],
+    repl: ReadableBuffer | Callable[[Match[bytes]], ReadableBuffer],
+    string: ReadableBuffer,
+    count: int = 0,
+    flags: _FlagsType = 0,
+) -> tuple[bytes, int]: ...
+
+def escape(pattern: AnyStr) -> AnyStr: ...
+def purge() -> None: ...
+
+if sys.version_info < (3, 13):
+    @deprecated("Deprecated since Python 3.11; removed in Python 3.13. Use `re.compile()` instead.")
+    def template(pattern: AnyStr | Pattern[AnyStr], flags: _FlagsType = 0) -> Pattern[AnyStr]: ...  # undocumented

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

@@ -0,0 +1,39 @@
+import sys
+from _typeshed import StrOrBytesPath
+from collections.abc import Callable, Sequence
+from typing import Literal, TypeAlias
+
+if sys.platform != "win32":
+    _Completer: TypeAlias = Callable[[str, int], str | None]
+    _CompDisp: TypeAlias = Callable[[str, Sequence[str], int], None]
+
+    def parse_and_bind(string: str, /) -> None: ...
+    def read_init_file(filename: StrOrBytesPath | None = None, /) -> None: ...
+    def get_line_buffer() -> str: ...
+    def insert_text(string: str, /) -> None: ...
+    def redisplay() -> None: ...
+    def read_history_file(filename: StrOrBytesPath | None = None, /) -> None: ...
+    def write_history_file(filename: StrOrBytesPath | None = None, /) -> None: ...
+    def append_history_file(nelements: int, filename: StrOrBytesPath | None = None, /) -> None: ...
+    def get_history_length() -> int: ...
+    def set_history_length(length: int, /) -> None: ...
+    def clear_history() -> None: ...
+    def get_current_history_length() -> int: ...
+    def get_history_item(index: int, /) -> str: ...
+    def remove_history_item(pos: int, /) -> None: ...
+    def replace_history_item(pos: int, line: str, /) -> None: ...
+    def add_history(string: str, /) -> None: ...
+    def set_auto_history(enabled: bool, /) -> None: ...
+    def set_startup_hook(function: Callable[[], object] | None = None, /) -> None: ...
+    def set_pre_input_hook(function: Callable[[], object] | None = None, /) -> None: ...
+    def set_completer(function: _Completer | None = None, /) -> None: ...
+    def get_completer() -> _Completer | None: ...
+    def get_completion_type() -> int: ...
+    def get_begidx() -> int: ...
+    def get_endidx() -> int: ...
+    def set_completer_delims(string: str, /) -> None: ...
+    def get_completer_delims() -> str: ...
+    def set_completion_display_matches_hook(function: _CompDisp | None = None, /) -> None: ...
+
+    if sys.version_info >= (3, 13):
+        backend: Literal["readline", "editline"]

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

@@ -0,0 +1,64 @@
+import sys
+from array import array
+from collections import deque
+from collections.abc import Callable
+from typing import Any, TypeAlias
+
+__all__ = ["Repr", "repr", "recursive_repr"]
+
+_ReprFunc: TypeAlias = Callable[[Any], str]
+
+def recursive_repr(fillvalue: str = "...") -> Callable[[_ReprFunc], _ReprFunc]: ...
+
+class Repr:
+    maxlevel: int
+    maxdict: int
+    maxlist: int
+    maxtuple: int
+    maxset: int
+    maxfrozenset: int
+    maxdeque: int
+    maxarray: int
+    maxlong: int
+    maxstring: int
+    maxother: int
+    if sys.version_info >= (3, 11):
+        fillvalue: str
+    if sys.version_info >= (3, 12):
+        indent: str | int | None
+
+    if sys.version_info >= (3, 12):
+        def __init__(
+            self,
+            *,
+            maxlevel: int = 6,
+            maxtuple: int = 6,
+            maxlist: int = 6,
+            maxarray: int = 5,
+            maxdict: int = 4,
+            maxset: int = 6,
+            maxfrozenset: int = 6,
+            maxdeque: int = 6,
+            maxstring: int = 30,
+            maxlong: int = 40,
+            maxother: int = 30,
+            fillvalue: str = "...",
+            indent: str | int | None = None,
+        ) -> None: ...
+
+    def repr(self, x: Any) -> str: ...
+    def repr1(self, x: Any, level: int) -> str: ...
+    def repr_tuple(self, x: tuple[Any, ...], level: int) -> str: ...
+    def repr_list(self, x: list[Any], level: int) -> str: ...
+    def repr_array(self, x: array[Any], level: int) -> str: ...
+    def repr_set(self, x: set[Any], level: int) -> str: ...
+    def repr_frozenset(self, x: frozenset[Any], level: int) -> str: ...
+    def repr_deque(self, x: deque[Any], level: int) -> str: ...
+    def repr_dict(self, x: dict[Any, Any], level: int) -> str: ...
+    def repr_str(self, x: str, level: int) -> str: ...
+    def repr_int(self, x: int, level: int) -> str: ...
+    def repr_instance(self, x: Any, level: int) -> str: ...
+
+aRepr: Repr
+
+def repr(x: object) -> str: ...

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

@@ -0,0 +1,102 @@
+import sys
+from _typeshed import structseq
+from typing import Final, final
+
+if sys.platform != "win32":
+    # Depends on resource.h
+    RLIMIT_AS: Final[int]
+    RLIMIT_CORE: Final[int]
+    RLIMIT_CPU: Final[int]
+    RLIMIT_DATA: Final[int]
+    RLIMIT_FSIZE: Final[int]
+    RLIMIT_MEMLOCK: Final[int]
+    RLIMIT_NOFILE: Final[int]
+    RLIMIT_NPROC: Final[int]
+    RLIMIT_RSS: Final[int]
+    RLIMIT_STACK: Final[int]
+    RLIM_INFINITY: Final[int]
+    if sys.version_info >= (3, 15):
+        RLIM_SAVED_CUR: Final[int]
+        RLIM_SAVED_MAX: Final[int]
+    RUSAGE_CHILDREN: Final[int]
+    RUSAGE_SELF: Final[int]
+    if sys.platform == "linux":
+        RLIMIT_MSGQUEUE: Final[int]
+        RLIMIT_NICE: Final[int]
+        RLIMIT_OFILE: Final[int]
+        RLIMIT_RTPRIO: Final[int]
+        RLIMIT_RTTIME: Final[int]
+        RLIMIT_SIGPENDING: Final[int]
+        RUSAGE_THREAD: Final[int]
+    if sys.version_info >= (3, 15) and sys.platform != "linux" and sys.platform != "darwin":
+        RLIMIT_NTHR: Final[int]
+        RLIMIT_PIPEBUF: Final[int]
+        RLIMIT_THREADS: Final[int]
+        RLIMIT_UMTXP: Final[int]
+
+    @final
+    class struct_rusage(
+        structseq[float], tuple[float, float, int, int, int, int, int, int, int, int, int, int, int, int, int, int]
+    ):
+        __match_args__: Final = (
+            "ru_utime",
+            "ru_stime",
+            "ru_maxrss",
+            "ru_ixrss",
+            "ru_idrss",
+            "ru_isrss",
+            "ru_minflt",
+            "ru_majflt",
+            "ru_nswap",
+            "ru_inblock",
+            "ru_oublock",
+            "ru_msgsnd",
+            "ru_msgrcv",
+            "ru_nsignals",
+            "ru_nvcsw",
+            "ru_nivcsw",
+        )
+
+        @property
+        def ru_utime(self) -> float: ...
+        @property
+        def ru_stime(self) -> float: ...
+        @property
+        def ru_maxrss(self) -> int: ...
+        @property
+        def ru_ixrss(self) -> int: ...
+        @property
+        def ru_idrss(self) -> int: ...
+        @property
+        def ru_isrss(self) -> int: ...
+        @property
+        def ru_minflt(self) -> int: ...
+        @property
+        def ru_majflt(self) -> int: ...
+        @property
+        def ru_nswap(self) -> int: ...
+        @property
+        def ru_inblock(self) -> int: ...
+        @property
+        def ru_oublock(self) -> int: ...
+        @property
+        def ru_msgsnd(self) -> int: ...
+        @property
+        def ru_msgrcv(self) -> int: ...
+        @property
+        def ru_nsignals(self) -> int: ...
+        @property
+        def ru_nvcsw(self) -> int: ...
+        @property
+        def ru_nivcsw(self) -> int: ...
+
+    def getpagesize() -> int: ...
+    def getrlimit(resource: int, /) -> tuple[int, int]: ...
+    def getrusage(who: int, /) -> struct_rusage: ...
+    def setrlimit(resource: int, limits: tuple[int, int], /) -> None: ...
+    if sys.platform == "linux":
+        if sys.version_info >= (3, 12):
+            def prlimit(pid: int, resource: int, limits: tuple[int, int] | None = None, /) -> tuple[int, int]: ...
+        else:
+            def prlimit(pid: int, resource: int, limits: tuple[int, int] = ..., /) -> tuple[int, int]: ...
+    error = OSError

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

@@ -0,0 +1,9 @@
+from typing import Any
+
+__all__ = ["Completer"]
+
+class Completer:
+    def __init__(self, namespace: dict[str, Any] | None = None) -> None: ...
+    def complete(self, text: str, state: int) -> str | None: ...
+    def attr_matches(self, text: str) -> list[str]: ...
+    def global_matches(self, text: str) -> list[str]: ...