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

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

@@ -0,0 +1,160 @@
+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
+
+__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",
+]
+
+if sys.version_info >= (3, 9):
+    __all__ += ["randbytes"]
+if sys.version_info >= (3, 12):
+    __all__ += ["binomialvariate"]
+
+_T = TypeVar("_T")
+
+class Random(_random.Random):
+    VERSION: ClassVar[int]
+    def __init__(self, x: Any = None) -> None: ...
+    # 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.
+    if sys.version_info >= (3, 9):
+        def seed(self, a: int | float | str | bytes | bytearray | None = None, version: int = 2) -> None: ...  # type: ignore[override]  # noqa: Y041
+    else:
+        def seed(self, a: Any = None, version: int = 2) -> None: ...
+
+    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: ...
+    if sys.version_info >= (3, 9):
+        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:
+        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]: ...
+    elif sys.version_info >= (3, 9):
+        def sample(
+            self,
+            population: Sequence[_T] | AbstractSet[_T],
+            k: int,
+            *,
+            counts: Iterable[int] | None = None,
+        ) -> list[_T]: ...
+    else:
+        def sample(
+            self, population: Sequence[_T] | AbstractSet[_T], k: int
+        ) -> 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
+if sys.version_info >= (3, 9):
+    randbytes = _inst.randbytes

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

@@ -0,0 +1,376 @@
+import enum
+import sre_compile
+import sys
+from _typeshed import ReadableBuffer
+from collections.abc import Callable, Iterator, Mapping
+from sre_constants import error as error
+from typing import Any, AnyStr, Generic, Literal, TypeVar, final, overload
+from typing_extensions import TypeAlias
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+__all__ = [
+    "match",
+    "fullmatch",
+    "search",
+    "sub",
+    "subn",
+    "split",
+    "findall",
+    "finditer",
+    "compile",
+    "purge",
+    "template",
+    "escape",
+    "error",
+    "A",
+    "I",
+    "L",
+    "M",
+    "S",
+    "X",
+    "U",
+    "ASCII",
+    "IGNORECASE",
+    "LOCALE",
+    "MULTILINE",
+    "DOTALL",
+    "VERBOSE",
+    "UNICODE",
+    "Match",
+    "Pattern",
+]
+
+if sys.version_info >= (3, 11):
+    __all__ += ["NOFLAG", "RegexFlag"]
+
+_T = TypeVar("_T")
+
+@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: ...  # type: ignore[overload-overlap]
+    @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 | Any: ...
+    @overload
+    def group(
+        self, __group1: str | int, __group2: str | int, *groups: str | int
+    ) -> tuple[AnyStr | Any, ...]: ...
+    # Each item of groups()'s return tuple is either "AnyStr" or
+    # "AnyStr | None", depending on the pattern.
+    @overload
+    def groups(self) -> tuple[AnyStr | Any, ...]: ...
+    @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 | Any]: ...
+    @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 | Any: ...
+    def __copy__(self) -> Match[AnyStr]: ...
+    def __deepcopy__(self, __memo: Any) -> Match[AnyStr]: ...
+    if sys.version_info >= (3, 9):
+        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: ...  # type: ignore[overload-overlap]
+    @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: ...  # type: ignore[overload-overlap]
+    @overload
+    def match(
+        self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize
+    ) -> Match[AnyStr] | None: ...
+    @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: ...  # type: ignore[overload-overlap]
+    @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 | Any]: ...
+    @overload
+    def split(
+        self: Pattern[bytes], string: ReadableBuffer, maxsplit: int = 0
+    ) -> list[bytes | Any]: ...
+    @overload
+    def split(self, string: AnyStr, maxsplit: int = 0) -> list[AnyStr | Any]: ...
+    # 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]]: ...  # type: ignore[overload-overlap]
+    @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(  # type: ignore[overload-overlap]
+        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(  # type: ignore[overload-overlap]
+        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: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+# ----- re variables and constants -----
+
+class RegexFlag(enum.IntFlag):
+    A = sre_compile.SRE_FLAG_ASCII
+    ASCII = A
+    DEBUG = sre_compile.SRE_FLAG_DEBUG
+    I = sre_compile.SRE_FLAG_IGNORECASE
+    IGNORECASE = I
+    L = sre_compile.SRE_FLAG_LOCALE
+    LOCALE = L
+    M = sre_compile.SRE_FLAG_MULTILINE
+    MULTILINE = M
+    S = sre_compile.SRE_FLAG_DOTALL
+    DOTALL = S
+    X = sre_compile.SRE_FLAG_VERBOSE
+    VERBOSE = X
+    U = sre_compile.SRE_FLAG_UNICODE
+    UNICODE = U
+    T = sre_compile.SRE_FLAG_TEMPLATE
+    TEMPLATE = T
+    if sys.version_info >= (3, 11):
+        NOFLAG: int
+
+A = RegexFlag.A
+ASCII = RegexFlag.ASCII
+DEBUG = RegexFlag.DEBUG
+I = RegexFlag.I
+IGNORECASE = RegexFlag.IGNORECASE
+L = RegexFlag.L
+LOCALE = RegexFlag.LOCALE
+M = RegexFlag.M
+MULTILINE = RegexFlag.MULTILINE
+S = RegexFlag.S
+DOTALL = RegexFlag.DOTALL
+X = RegexFlag.X
+VERBOSE = RegexFlag.VERBOSE
+U = RegexFlag.U
+UNICODE = RegexFlag.UNICODE
+T = RegexFlag.T
+TEMPLATE = RegexFlag.TEMPLATE
+if sys.version_info >= (3, 11):
+    NOFLAG = 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: ...
+@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 | Any]: ...
+@overload
+def split(
+    pattern: bytes | Pattern[bytes],
+    string: ReadableBuffer,
+    maxsplit: int = 0,
+    flags: _FlagsType = 0,
+) -> list[bytes | Any]: ...
+@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: ...
+def template(
+    pattern: AnyStr | Pattern[AnyStr], flags: _FlagsType = 0
+) -> Pattern[AnyStr]: ...

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

@@ -0,0 +1,40 @@
+import sys
+from _typeshed import StrOrBytesPath
+from collections.abc import Callable, Sequence
+from typing_extensions import 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: ...

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

@@ -0,0 +1,65 @@
+import sys
+from array import array
+from collections import deque
+from collections.abc import Callable
+from typing import Any
+from typing_extensions import 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: ...