jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

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

@@ -1,66 +0,0 @@
-import sys
-from threading import Condition, Lock
-from typing import Any, Generic, TypeVar
-
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
-__all__ = ["Empty", "Full", "Queue", "PriorityQueue", "LifoQueue", "SimpleQueue"]
-
-_T = TypeVar("_T")
-
-class Empty(Exception): ...
-class Full(Exception): ...
-
-if sys.version_info >= (3, 13):
-    class ShutDown(Exception): ...
-
-class Queue(Generic[_T]):
-    maxsize: int
-
-    mutex: Lock  # undocumented
-    not_empty: Condition  # undocumented
-    not_full: Condition  # undocumented
-    all_tasks_done: Condition  # undocumented
-    unfinished_tasks: int  # undocumented
-    if sys.version_info >= (3, 13):
-        is_shutdown: bool  # undocumented
-    # Despite the fact that `queue` has `deque` type,
-    # we treat it as `Any` to allow different implementations in subtypes.
-    queue: Any  # undocumented
-    def __init__(self, maxsize: int = 0) -> None: ...
-    def _init(self, maxsize: int) -> None: ...
-    def empty(self) -> bool: ...
-    def full(self) -> bool: ...
-    def get(self, block: bool = True, timeout: float | None = None) -> _T: ...
-    def get_nowait(self) -> _T: ...
-    if sys.version_info >= (3, 13):
-        def shutdown(self, immediate: bool = False) -> None: ...
-
-    def _get(self) -> _T: ...
-    def put(self, item: _T, block: bool = True, timeout: float | None = None) -> None: ...
-    def put_nowait(self, item: _T) -> None: ...
-    def _put(self, item: _T) -> None: ...
-    def join(self) -> None: ...
-    def qsize(self) -> int: ...
-    def _qsize(self) -> int: ...
-    def task_done(self) -> None: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
-
-class PriorityQueue(Queue[_T]):
-    queue: list[_T]
-
-class LifoQueue(Queue[_T]):
-    queue: list[_T]
-
-class SimpleQueue(Generic[_T]):
-    def __init__(self) -> None: ...
-    def empty(self) -> bool: ...
-    def get(self, block: bool = True, timeout: float | None = None) -> _T: ...
-    def get_nowait(self) -> _T: ...
-    def put(self, item: _T, block: bool = True, timeout: float | None = None) -> None: ...
-    def put_nowait(self, item: _T) -> None: ...
-    def qsize(self) -> int: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...

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

@@ -1,11 +0,0 @@
-from _typeshed import ReadableBuffer, SupportsNoArgReadline, SupportsRead, SupportsWrite
-from typing import Protocol
-
-__all__ = ["encode", "decode", "encodestring", "decodestring"]
-
-class _Input(SupportsRead[bytes], SupportsNoArgReadline[bytes], Protocol): ...
-
-def encode(input: _Input, output: SupportsWrite[bytes], quotetabs: int, header: bool = False) -> None: ...
-def encodestring(s: ReadableBuffer, quotetabs: bool = False, header: bool = False) -> bytes: ...
-def decode(input: _Input, output: SupportsWrite[bytes], header: bool = False) -> None: ...
-def decodestring(s: str | ReadableBuffer, header: bool = False) -> bytes: ...

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

@@ -1,138 +0,0 @@
-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

@@ -1,290 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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: ...