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

jaclang/vendor/mypy/typeshed/stdlib/os/path.pyi

@@ -0,0 +1,8 @@
+import sys
+
+if sys.platform == "win32":
+    from ntpath import *
+    from ntpath import __all__ as __all__
+else:
+    from posixpath import *
+    from posixpath import __all__ as __all__

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

@@ -0,0 +1,131 @@
+import sys
+from typing import Any, Literal, overload
+
+if sys.platform != "win32" and sys.platform != "darwin":
+    AFMT_AC3: int
+    AFMT_A_LAW: int
+    AFMT_IMA_ADPCM: int
+    AFMT_MPEG: int
+    AFMT_MU_LAW: int
+    AFMT_QUERY: int
+    AFMT_S16_BE: int
+    AFMT_S16_LE: int
+    AFMT_S16_NE: int
+    AFMT_S8: int
+    AFMT_U16_BE: int
+    AFMT_U16_LE: int
+    AFMT_U8: int
+    SNDCTL_COPR_HALT: int
+    SNDCTL_COPR_LOAD: int
+    SNDCTL_COPR_RCODE: int
+    SNDCTL_COPR_RCVMSG: int
+    SNDCTL_COPR_RDATA: int
+    SNDCTL_COPR_RESET: int
+    SNDCTL_COPR_RUN: int
+    SNDCTL_COPR_SENDMSG: int
+    SNDCTL_COPR_WCODE: int
+    SNDCTL_COPR_WDATA: int
+    SNDCTL_DSP_BIND_CHANNEL: int
+    SNDCTL_DSP_CHANNELS: int
+    SNDCTL_DSP_GETBLKSIZE: int
+    SNDCTL_DSP_GETCAPS: int
+    SNDCTL_DSP_GETCHANNELMASK: int
+    SNDCTL_DSP_GETFMTS: int
+    SNDCTL_DSP_GETIPTR: int
+    SNDCTL_DSP_GETISPACE: int
+    SNDCTL_DSP_GETODELAY: int
+    SNDCTL_DSP_GETOPTR: int
+    SNDCTL_DSP_GETOSPACE: int
+    SNDCTL_DSP_GETSPDIF: int
+    SNDCTL_DSP_GETTRIGGER: int
+    SNDCTL_DSP_MAPINBUF: int
+    SNDCTL_DSP_MAPOUTBUF: int
+    SNDCTL_DSP_NONBLOCK: int
+    SNDCTL_DSP_POST: int
+    SNDCTL_DSP_PROFILE: int
+    SNDCTL_DSP_RESET: int
+    SNDCTL_DSP_SAMPLESIZE: int
+    SNDCTL_DSP_SETDUPLEX: int
+    SNDCTL_DSP_SETFMT: int
+    SNDCTL_DSP_SETFRAGMENT: int
+    SNDCTL_DSP_SETSPDIF: int
+    SNDCTL_DSP_SETSYNCRO: int
+    SNDCTL_DSP_SETTRIGGER: int
+    SNDCTL_DSP_SPEED: int
+    SNDCTL_DSP_STEREO: int
+    SNDCTL_DSP_SUBDIVIDE: int
+    SNDCTL_DSP_SYNC: int
+    SNDCTL_FM_4OP_ENABLE: int
+    SNDCTL_FM_LOAD_INSTR: int
+    SNDCTL_MIDI_INFO: int
+    SNDCTL_MIDI_MPUCMD: int
+    SNDCTL_MIDI_MPUMODE: int
+    SNDCTL_MIDI_PRETIME: int
+    SNDCTL_SEQ_CTRLRATE: int
+    SNDCTL_SEQ_GETINCOUNT: int
+    SNDCTL_SEQ_GETOUTCOUNT: int
+    SNDCTL_SEQ_GETTIME: int
+    SNDCTL_SEQ_NRMIDIS: int
+    SNDCTL_SEQ_NRSYNTHS: int
+    SNDCTL_SEQ_OUTOFBAND: int
+    SNDCTL_SEQ_PANIC: int
+    SNDCTL_SEQ_PERCMODE: int
+    SNDCTL_SEQ_RESET: int
+    SNDCTL_SEQ_RESETSAMPLES: int
+    SNDCTL_SEQ_SYNC: int
+    SNDCTL_SEQ_TESTMIDI: int
+    SNDCTL_SEQ_THRESHOLD: int
+    SNDCTL_SYNTH_CONTROL: int
+    SNDCTL_SYNTH_ID: int
+    SNDCTL_SYNTH_INFO: int
+    SNDCTL_SYNTH_MEMAVL: int
+    SNDCTL_SYNTH_REMOVESAMPLE: int
+    SNDCTL_TMR_CONTINUE: int
+    SNDCTL_TMR_METRONOME: int
+    SNDCTL_TMR_SELECT: int
+    SNDCTL_TMR_SOURCE: int
+    SNDCTL_TMR_START: int
+    SNDCTL_TMR_STOP: int
+    SNDCTL_TMR_TEMPO: int
+    SNDCTL_TMR_TIMEBASE: int
+    SOUND_MIXER_ALTPCM: int
+    SOUND_MIXER_BASS: int
+    SOUND_MIXER_CD: int
+    SOUND_MIXER_DIGITAL1: int
+    SOUND_MIXER_DIGITAL2: int
+    SOUND_MIXER_DIGITAL3: int
+    SOUND_MIXER_IGAIN: int
+    SOUND_MIXER_IMIX: int
+    SOUND_MIXER_LINE: int
+    SOUND_MIXER_LINE1: int
+    SOUND_MIXER_LINE2: int
+    SOUND_MIXER_LINE3: int
+    SOUND_MIXER_MIC: int
+    SOUND_MIXER_MONITOR: int
+    SOUND_MIXER_NRDEVICES: int
+    SOUND_MIXER_OGAIN: int
+    SOUND_MIXER_PCM: int
+    SOUND_MIXER_PHONEIN: int
+    SOUND_MIXER_PHONEOUT: int
+    SOUND_MIXER_RADIO: int
+    SOUND_MIXER_RECLEV: int
+    SOUND_MIXER_SPEAKER: int
+    SOUND_MIXER_SYNTH: int
+    SOUND_MIXER_TREBLE: int
+    SOUND_MIXER_VIDEO: int
+    SOUND_MIXER_VOLUME: int
+
+    control_labels: list[str]
+    control_names: list[str]
+
+    # TODO: oss_audio_device return type
+    @overload
+    def open(mode: Literal["r", "w", "rw"]) -> Any: ...
+    @overload
+    def open(device: str, mode: Literal["r", "w", "rw"]) -> Any: ...
+
+    # TODO: oss_mixer_device return type
+    def openmixer(device: str = ...) -> Any: ...
+
+    class OSSAudioError(Exception): ...
+    error = OSSAudioError

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

@@ -0,0 +1,28 @@
+from _typeshed import StrOrBytesPath
+from collections.abc import Sequence
+from types import CodeType
+from typing import Any, final
+
+def expr(source: str) -> STType: ...
+def suite(source: str) -> STType: ...
+def sequence2st(sequence: Sequence[Any]) -> STType: ...
+def tuple2st(sequence: Sequence[Any]) -> STType: ...
+def st2list(st: STType, line_info: bool = ..., col_info: bool = ...) -> list[Any]: ...
+def st2tuple(
+    st: STType, line_info: bool = ..., col_info: bool = ...
+) -> tuple[Any, ...]: ...
+def compilest(st: STType, filename: StrOrBytesPath = ...) -> CodeType: ...
+def isexpr(st: STType) -> bool: ...
+def issuite(st: STType) -> bool: ...
+
+class ParserError(Exception): ...
+
+@final
+class STType:
+    def compile(self, filename: StrOrBytesPath = ...) -> CodeType: ...
+    def isexpr(self) -> bool: ...
+    def issuite(self) -> bool: ...
+    def tolist(self, line_info: bool = ..., col_info: bool = ...) -> list[Any]: ...
+    def totuple(
+        self, line_info: bool = ..., col_info: bool = ...
+    ) -> tuple[Any, ...]: ...

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

@@ -0,0 +1,282 @@
+import sys
+from _typeshed import (
+    OpenBinaryMode,
+    OpenBinaryModeReading,
+    OpenBinaryModeUpdating,
+    OpenBinaryModeWriting,
+    OpenTextMode,
+    ReadableBuffer,
+    StrOrBytesPath,
+    StrPath,
+    Unused,
+)
+from collections.abc import Callable, Generator, Iterator, Sequence
+from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper
+from os import PathLike, stat_result
+from types import TracebackType
+from typing import IO, Any, BinaryIO, Literal, overload
+from typing_extensions import Self
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+__all__ = [
+    "PurePath",
+    "PurePosixPath",
+    "PureWindowsPath",
+    "Path",
+    "PosixPath",
+    "WindowsPath",
+]
+
+class PurePath(PathLike[str]):
+    @property
+    def parts(self) -> tuple[str, ...]: ...
+    @property
+    def drive(self) -> str: ...
+    @property
+    def root(self) -> str: ...
+    @property
+    def anchor(self) -> str: ...
+    @property
+    def name(self) -> str: ...
+    @property
+    def suffix(self) -> str: ...
+    @property
+    def suffixes(self) -> list[str]: ...
+    @property
+    def stem(self) -> str: ...
+    if sys.version_info >= (3, 12):
+        def __new__(cls, *args: StrPath, **kwargs: Unused) -> Self: ...
+        def __init__(self, *args: StrPath) -> None: ...
+    else:
+        def __new__(cls, *args: StrPath) -> Self: ...
+
+    def __hash__(self) -> int: ...
+    def __fspath__(self) -> str: ...
+    def __lt__(self, other: PurePath) -> bool: ...
+    def __le__(self, other: PurePath) -> bool: ...
+    def __gt__(self, other: PurePath) -> bool: ...
+    def __ge__(self, other: PurePath) -> bool: ...
+    def __truediv__(self, key: StrPath) -> Self: ...
+    def __rtruediv__(self, key: StrPath) -> Self: ...
+    def __bytes__(self) -> bytes: ...
+    def as_posix(self) -> str: ...
+    def as_uri(self) -> str: ...
+    def is_absolute(self) -> bool: ...
+    def is_reserved(self) -> bool: ...
+    if sys.version_info >= (3, 12):
+        def is_relative_to(self, __other: StrPath, *_deprecated: StrPath) -> bool: ...
+    elif sys.version_info >= (3, 9):
+        def is_relative_to(self, *other: StrPath) -> bool: ...
+
+    if sys.version_info >= (3, 12):
+        def match(
+            self, path_pattern: str, *, case_sensitive: bool | None = None
+        ) -> bool: ...
+    else:
+        def match(self, path_pattern: str) -> bool: ...
+
+    if sys.version_info >= (3, 12):
+        def relative_to(
+            self, __other: StrPath, *_deprecated: StrPath, walk_up: bool = False
+        ) -> Self: ...
+    else:
+        def relative_to(self, *other: StrPath) -> Self: ...
+
+    def with_name(self, name: str) -> Self: ...
+    if sys.version_info >= (3, 9):
+        def with_stem(self, stem: str) -> Self: ...
+
+    def with_suffix(self, suffix: str) -> Self: ...
+    def joinpath(self, *other: StrPath) -> Self: ...
+    @property
+    def parents(self) -> Sequence[Self]: ...
+    @property
+    def parent(self) -> Self: ...
+    if sys.version_info >= (3, 9) and sys.version_info < (3, 11):
+        def __class_getitem__(cls, type: Any) -> GenericAlias: ...
+
+    if sys.version_info >= (3, 12):
+        def with_segments(self, *args: StrPath) -> Self: ...
+
+class PurePosixPath(PurePath): ...
+class PureWindowsPath(PurePath): ...
+
+class Path(PurePath):
+    def __new__(cls, *args: StrPath, **kwargs: Any) -> Self: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self,
+        t: type[BaseException] | None,
+        v: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None: ...
+    @classmethod
+    def cwd(cls) -> Self: ...
+    if sys.version_info >= (3, 10):
+        def stat(self, *, follow_symlinks: bool = True) -> stat_result: ...
+        def chmod(self, mode: int, *, follow_symlinks: bool = True) -> None: ...
+    else:
+        def stat(self) -> stat_result: ...
+        def chmod(self, mode: int) -> None: ...
+
+    if sys.version_info >= (3, 12):
+        def exists(self, *, follow_symlinks: bool = True) -> bool: ...
+        def glob(
+            self, pattern: str, *, case_sensitive: bool | None = None
+        ) -> Generator[Self, None, None]: ...
+        def rglob(
+            self, pattern: str, *, case_sensitive: bool | None = None
+        ) -> Generator[Self, None, None]: ...
+    else:
+        def exists(self) -> bool: ...
+        def glob(self, pattern: str) -> Generator[Self, None, None]: ...
+        def rglob(self, pattern: str) -> Generator[Self, None, None]: ...
+
+    def is_dir(self) -> bool: ...
+    def is_file(self) -> bool: ...
+    def is_symlink(self) -> bool: ...
+    def is_socket(self) -> bool: ...
+    def is_fifo(self) -> bool: ...
+    def is_block_device(self) -> bool: ...
+    def is_char_device(self) -> bool: ...
+    if sys.version_info >= (3, 12):
+        def is_junction(self) -> bool: ...
+
+    def iterdir(self) -> Generator[Self, None, None]: ...
+    def lchmod(self, mode: int) -> None: ...
+    def lstat(self) -> stat_result: ...
+    def mkdir(
+        self, mode: int = 0o777, parents: bool = False, exist_ok: bool = False
+    ) -> None: ...
+    # Adapted from builtins.open
+    # Text mode: always returns a TextIOWrapper
+    # The Traversable .open in stdlib/importlib/abc.pyi should be kept in sync with this.
+    @overload
+    def open(
+        self,
+        mode: OpenTextMode = "r",
+        buffering: int = -1,
+        encoding: str | None = None,
+        errors: str | None = None,
+        newline: str | None = None,
+    ) -> TextIOWrapper: ...
+    # Unbuffered binary mode: returns a FileIO
+    @overload
+    def open(
+        self,
+        mode: OpenBinaryMode,
+        buffering: Literal[0],
+        encoding: None = None,
+        errors: None = None,
+        newline: None = None,
+    ) -> FileIO: ...
+    # Buffering is on: return BufferedRandom, BufferedReader, or BufferedWriter
+    @overload
+    def open(
+        self,
+        mode: OpenBinaryModeUpdating,
+        buffering: Literal[-1, 1] = -1,
+        encoding: None = None,
+        errors: None = None,
+        newline: None = None,
+    ) -> BufferedRandom: ...
+    @overload
+    def open(
+        self,
+        mode: OpenBinaryModeWriting,
+        buffering: Literal[-1, 1] = -1,
+        encoding: None = None,
+        errors: None = None,
+        newline: None = None,
+    ) -> BufferedWriter: ...
+    @overload
+    def open(
+        self,
+        mode: OpenBinaryModeReading,
+        buffering: Literal[-1, 1] = -1,
+        encoding: None = None,
+        errors: None = None,
+        newline: None = None,
+    ) -> BufferedReader: ...
+    # Buffering cannot be determined: fall back to BinaryIO
+    @overload
+    def open(
+        self,
+        mode: OpenBinaryMode,
+        buffering: int = -1,
+        encoding: None = None,
+        errors: None = None,
+        newline: None = None,
+    ) -> BinaryIO: ...
+    # Fallback if mode is not specified
+    @overload
+    def open(
+        self,
+        mode: str,
+        buffering: int = -1,
+        encoding: str | None = None,
+        errors: str | None = None,
+        newline: str | None = None,
+    ) -> IO[Any]: ...
+    if sys.platform != "win32":
+        # These methods do "exist" on Windows, but they always raise NotImplementedError,
+        # so it's safer to pretend they don't exist
+        def owner(self) -> str: ...
+        def group(self) -> str: ...
+
+    # This method does "exist" on Windows on <3.12, but always raises NotImplementedError
+    # On py312+, it works properly on Windows, as with all other platforms
+    if sys.platform != "win32" or sys.version_info >= (3, 12):
+        def is_mount(self) -> bool: ...
+
+    if sys.version_info >= (3, 9):
+        def readlink(self) -> Self: ...
+
+    def rename(self, target: str | PurePath) -> Self: ...
+    def replace(self, target: str | PurePath) -> Self: ...
+    def resolve(self, strict: bool = False) -> Self: ...
+    def rmdir(self) -> None: ...
+    def symlink_to(
+        self, target: StrOrBytesPath, target_is_directory: bool = False
+    ) -> None: ...
+    if sys.version_info >= (3, 10):
+        def hardlink_to(self, target: StrOrBytesPath) -> None: ...
+
+    def touch(self, mode: int = 0o666, exist_ok: bool = True) -> None: ...
+    def unlink(self, missing_ok: bool = False) -> None: ...
+    @classmethod
+    def home(cls) -> Self: ...
+    def absolute(self) -> Self: ...
+    def expanduser(self) -> Self: ...
+    def read_bytes(self) -> bytes: ...
+    def read_text(
+        self, encoding: str | None = None, errors: str | None = None
+    ) -> str: ...
+    def samefile(self, other_path: StrPath) -> bool: ...
+    def write_bytes(self, data: ReadableBuffer) -> int: ...
+    if sys.version_info >= (3, 10):
+        def write_text(
+            self,
+            data: str,
+            encoding: str | None = None,
+            errors: str | None = None,
+            newline: str | None = None,
+        ) -> int: ...
+    else:
+        def write_text(
+            self, data: str, encoding: str | None = None, errors: str | None = None
+        ) -> int: ...
+    if sys.version_info < (3, 12):
+        def link_to(self, target: StrOrBytesPath) -> None: ...
+    if sys.version_info >= (3, 12):
+        def walk(
+            self,
+            top_down: bool = ...,
+            on_error: Callable[[OSError], object] | None = ...,
+            follow_symlinks: bool = ...,
+        ) -> Iterator[tuple[Self, list[str], list[str]]]: ...
+
+class PosixPath(Path, PurePosixPath): ...
+class WindowsPath(Path, PureWindowsPath): ...

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

@@ -0,0 +1,223 @@
+import signal
+import sys
+from bdb import Bdb
+from cmd import Cmd
+from collections.abc import Callable, Iterable, Mapping, Sequence
+from inspect import _SourceObjectType
+from types import CodeType, FrameType, TracebackType
+from typing import IO, Any, ClassVar, TypeVar
+from typing_extensions import ParamSpec, Self
+
+__all__ = [
+    "run",
+    "pm",
+    "Pdb",
+    "runeval",
+    "runctx",
+    "runcall",
+    "set_trace",
+    "post_mortem",
+    "help",
+]
+
+_T = TypeVar("_T")
+_P = ParamSpec("_P")
+
+line_prefix: str  # undocumented
+
+class Restart(Exception): ...
+
+def run(
+    statement: str,
+    globals: dict[str, Any] | None = None,
+    locals: Mapping[str, Any] | None = None,
+) -> None: ...
+def runeval(
+    expression: str,
+    globals: dict[str, Any] | None = None,
+    locals: Mapping[str, Any] | None = None,
+) -> Any: ...
+def runctx(
+    statement: str, globals: dict[str, Any], locals: Mapping[str, Any]
+) -> None: ...
+def runcall(func: Callable[_P, _T], *args: _P.args, **kwds: _P.kwargs) -> _T | None: ...
+def set_trace(*, header: str | None = None) -> None: ...
+def post_mortem(t: TracebackType | None = None) -> None: ...
+def pm() -> None: ...
+
+class Pdb(Bdb, Cmd):
+    # Everything here is undocumented, except for __init__
+
+    commands_resuming: ClassVar[list[str]]
+
+    aliases: dict[str, str]
+    mainpyfile: str
+    _wait_for_mainpyfile: bool
+    rcLines: list[str]
+    commands: dict[int, list[str]]
+    commands_doprompt: dict[int, bool]
+    commands_silent: dict[int, bool]
+    commands_defining: bool
+    commands_bnum: int | None
+    lineno: int | None
+    stack: list[tuple[FrameType, int]]
+    curindex: int
+    curframe: FrameType | None
+    curframe_locals: Mapping[str, Any]
+    def __init__(
+        self,
+        completekey: str = "tab",
+        stdin: IO[str] | None = None,
+        stdout: IO[str] | None = None,
+        skip: Iterable[str] | None = None,
+        nosigint: bool = False,
+        readrc: bool = True,
+    ) -> None: ...
+    def forget(self) -> None: ...
+    def setup(self, f: FrameType | None, tb: TracebackType | None) -> None: ...
+    def execRcLines(self) -> None: ...
+    def bp_commands(self, frame: FrameType) -> bool: ...
+    def interaction(
+        self, frame: FrameType | None, traceback: TracebackType | None
+    ) -> None: ...
+    def displayhook(self, obj: object) -> None: ...
+    def handle_command_def(self, line: str) -> bool: ...
+    def defaultFile(self) -> str: ...
+    def lineinfo(
+        self, identifier: str
+    ) -> tuple[None, None, None] | tuple[str, str, int]: ...
+    def checkline(self, filename: str, lineno: int) -> int: ...
+    def _getval(self, arg: str) -> object: ...
+    def print_stack_trace(self) -> None: ...
+    def print_stack_entry(
+        self, frame_lineno: tuple[FrameType, int], prompt_prefix: str = "\n-> "
+    ) -> None: ...
+    def lookupmodule(self, filename: str) -> str | None: ...
+    if sys.version_info < (3, 11):
+        def _runscript(self, filename: str) -> None: ...
+
+    def do_commands(self, arg: str) -> bool | None: ...
+    def do_break(self, arg: str, temporary: bool = ...) -> bool | None: ...
+    def do_tbreak(self, arg: str) -> bool | None: ...
+    def do_enable(self, arg: str) -> bool | None: ...
+    def do_disable(self, arg: str) -> bool | None: ...
+    def do_condition(self, arg: str) -> bool | None: ...
+    def do_ignore(self, arg: str) -> bool | None: ...
+    def do_clear(self, arg: str) -> bool | None: ...
+    def do_where(self, arg: str) -> bool | None: ...
+    def do_up(self, arg: str) -> bool | None: ...
+    def do_down(self, arg: str) -> bool | None: ...
+    def do_until(self, arg: str) -> bool | None: ...
+    def do_step(self, arg: str) -> bool | None: ...
+    def do_next(self, arg: str) -> bool | None: ...
+    def do_run(self, arg: str) -> bool | None: ...
+    def do_return(self, arg: str) -> bool | None: ...
+    def do_continue(self, arg: str) -> bool | None: ...
+    def do_jump(self, arg: str) -> bool | None: ...
+    def do_debug(self, arg: str) -> bool | None: ...
+    def do_quit(self, arg: str) -> bool | None: ...
+    def do_EOF(self, arg: str) -> bool | None: ...
+    def do_args(self, arg: str) -> bool | None: ...
+    def do_retval(self, arg: str) -> bool | None: ...
+    def do_p(self, arg: str) -> bool | None: ...
+    def do_pp(self, arg: str) -> bool | None: ...
+    def do_list(self, arg: str) -> bool | None: ...
+    def do_whatis(self, arg: str) -> bool | None: ...
+    def do_alias(self, arg: str) -> bool | None: ...
+    def do_unalias(self, arg: str) -> bool | None: ...
+    def do_help(self, arg: str) -> bool | None: ...
+    do_b = do_break
+    do_cl = do_clear
+    do_w = do_where
+    do_bt = do_where
+    do_u = do_up
+    do_d = do_down
+    do_unt = do_until
+    do_s = do_step
+    do_n = do_next
+    do_restart = do_run
+    do_r = do_return
+    do_c = do_continue
+    do_cont = do_continue
+    do_j = do_jump
+    do_q = do_quit
+    do_exit = do_quit
+    do_a = do_args
+    do_rv = do_retval
+    do_l = do_list
+    do_h = do_help
+    def help_exec(self) -> None: ...
+    def help_pdb(self) -> None: ...
+    def sigint_handler(self, signum: signal.Signals, frame: FrameType) -> None: ...
+    def message(self, msg: str) -> None: ...
+    def error(self, msg: str) -> None: ...
+    if sys.version_info >= (3, 12):
+        def set_convenience_variable(
+            self, frame: FrameType, name: str, value: Any
+        ) -> None: ...
+
+    def _select_frame(self, number: int) -> None: ...
+    def _getval_except(self, arg: str, frame: FrameType | None = None) -> object: ...
+    def _print_lines(
+        self,
+        lines: Sequence[str],
+        start: int,
+        breaks: Sequence[int] = (),
+        frame: FrameType | None = None,
+    ) -> None: ...
+    def _cmdloop(self) -> None: ...
+    def do_display(self, arg: str) -> bool | None: ...
+    def do_interact(self, arg: str) -> bool | None: ...
+    def do_longlist(self, arg: str) -> bool | None: ...
+    def do_source(self, arg: str) -> bool | None: ...
+    def do_undisplay(self, arg: str) -> bool | None: ...
+    do_ll = do_longlist
+    def _complete_location(
+        self, text: str, line: str, begidx: int, endidx: int
+    ) -> list[str]: ...
+    def _complete_bpnumber(
+        self, text: str, line: str, begidx: int, endidx: int
+    ) -> list[str]: ...
+    def _complete_expression(
+        self, text: str, line: str, begidx: int, endidx: int
+    ) -> list[str]: ...
+    def complete_undisplay(
+        self, text: str, line: str, begidx: int, endidx: int
+    ) -> list[str]: ...
+    def complete_unalias(
+        self, text: str, line: str, begidx: int, endidx: int
+    ) -> list[str]: ...
+    complete_commands = _complete_bpnumber
+    complete_break = _complete_location
+    complete_b = _complete_location
+    complete_tbreak = _complete_location
+    complete_enable = _complete_bpnumber
+    complete_disable = _complete_bpnumber
+    complete_condition = _complete_bpnumber
+    complete_ignore = _complete_bpnumber
+    complete_clear = _complete_location
+    complete_cl = _complete_location
+    complete_debug = _complete_expression
+    complete_print = _complete_expression
+    complete_p = _complete_expression
+    complete_pp = _complete_expression
+    complete_source = _complete_expression
+    complete_whatis = _complete_expression
+    complete_display = _complete_expression
+
+    if sys.version_info < (3, 11):
+        def _runmodule(self, module_name: str) -> None: ...
+
+# undocumented
+
+def find_function(funcname: str, filename: str) -> tuple[str, str, int] | None: ...
+def main() -> None: ...
+def help() -> None: ...
+
+if sys.version_info < (3, 10):
+    def getsourcelines(obj: _SourceObjectType) -> tuple[list[str], int]: ...
+
+def lasti2lineno(code: CodeType, lasti: int) -> int: ...
+
+class _rstr(str):
+    def __repr__(self) -> Self: ...