jaclang 0.6.1__py3-none-any.whl → 0.6.5__py3-none-any.whl

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

@@ -0,0 +1,48 @@
+import sys
+from typing import IO, Any, Literal, overload
+from typing_extensions import deprecated
+
+__all__ = [
+    "get_config_h_filename",
+    "get_config_var",
+    "get_config_vars",
+    "get_makefile_filename",
+    "get_path",
+    "get_path_names",
+    "get_paths",
+    "get_platform",
+    "get_python_version",
+    "get_scheme_names",
+    "parse_config_h",
+]
+
+@overload
+@deprecated("SO is deprecated, use EXT_SUFFIX. Support is removed in Python 3.11")
+def get_config_var(name: Literal["SO"]) -> Any: ...
+@overload
+def get_config_var(name: str) -> Any: ...
+@overload
+def get_config_vars() -> dict[str, Any]: ...
+@overload
+def get_config_vars(arg: str, /, *args: str) -> list[Any]: ...
+def get_scheme_names() -> tuple[str, ...]: ...
+
+if sys.version_info >= (3, 10):
+    def get_default_scheme() -> str: ...
+    def get_preferred_scheme(key: Literal["prefix", "home", "user"]) -> str: ...
+
+def get_path_names() -> tuple[str, ...]: ...
+def get_path(name: str, scheme: str = ..., vars: dict[str, Any] | None = None, expand: bool = True) -> str: ...
+def get_paths(scheme: str = ..., vars: dict[str, Any] | None = None, expand: bool = True) -> dict[str, str]: ...
+def get_python_version() -> str: ...
+def get_platform() -> str: ...
+
+if sys.version_info >= (3, 11):
+    def is_python_build(check_home: object = None) -> bool: ...
+
+else:
+    def is_python_build(check_home: bool = False) -> bool: ...
+
+def parse_config_h(fp: IO[Any], vars: dict[str, Any] | None = None) -> dict[str, Any]: ...
+def get_config_h_filename() -> str: ...
+def get_makefile_filename() -> str: ...

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

@@ -0,0 +1,46 @@
+import sys
+from typing import Literal, overload
+
+if sys.platform != "win32":
+    LOG_ALERT: Literal[1]
+    LOG_AUTH: Literal[32]
+    LOG_AUTHPRIV: Literal[80]
+    LOG_CONS: Literal[2]
+    LOG_CRIT: Literal[2]
+    LOG_CRON: Literal[72]
+    LOG_DAEMON: Literal[24]
+    LOG_DEBUG: Literal[7]
+    LOG_EMERG: Literal[0]
+    LOG_ERR: Literal[3]
+    LOG_INFO: Literal[6]
+    LOG_KERN: Literal[0]
+    LOG_LOCAL0: Literal[128]
+    LOG_LOCAL1: Literal[136]
+    LOG_LOCAL2: Literal[144]
+    LOG_LOCAL3: Literal[152]
+    LOG_LOCAL4: Literal[160]
+    LOG_LOCAL5: Literal[168]
+    LOG_LOCAL6: Literal[176]
+    LOG_LOCAL7: Literal[184]
+    LOG_LPR: Literal[48]
+    LOG_MAIL: Literal[16]
+    LOG_NDELAY: Literal[8]
+    LOG_NEWS: Literal[56]
+    LOG_NOTICE: Literal[5]
+    LOG_NOWAIT: Literal[16]
+    LOG_ODELAY: Literal[4]
+    LOG_PERROR: Literal[32]
+    LOG_PID: Literal[1]
+    LOG_SYSLOG: Literal[40]
+    LOG_USER: Literal[8]
+    LOG_UUCP: Literal[64]
+    LOG_WARNING: Literal[4]
+    def LOG_MASK(pri: int, /) -> int: ...
+    def LOG_UPTO(pri: int, /) -> int: ...
+    def closelog() -> None: ...
+    def openlog(ident: str = ..., logoption: int = ..., facility: int = ...) -> None: ...
+    def setlogmask(maskpri: int, /) -> int: ...
+    @overload
+    def syslog(priority: int, message: str) -> None: ...
+    @overload
+    def syslog(message: str) -> None: ...

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

@@ -0,0 +1,16 @@
+from _typeshed import StrOrBytesPath
+from collections.abc import Iterable
+
+__all__ = ["check", "NannyNag", "process_tokens"]
+
+verbose: int
+filename_only: int
+
+class NannyNag(Exception):
+    def __init__(self, lineno: int, msg: str, line: str) -> None: ...
+    def get_lineno(self) -> int: ...
+    def get_msg(self) -> str: ...
+    def get_line(self) -> str: ...
+
+def check(file: StrOrBytesPath) -> None: ...
+def process_tokens(tokens: Iterable[tuple[int, str, tuple[int, int], tuple[int, int], str]]) -> None: ...

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

@@ -0,0 +1,441 @@
+import bz2
+import io
+import sys
+from _typeshed import StrOrBytesPath, StrPath
+from builtins import list as _list  # aliases to avoid name clashes with fields named "type" or "list"
+from collections.abc import Callable, Iterable, Iterator, Mapping
+from gzip import _ReadableFileobj as _GzipReadableFileobj, _WritableFileobj as _GzipWritableFileobj
+from types import TracebackType
+from typing import IO, ClassVar, Literal, Protocol, overload
+from typing_extensions import Self, TypeAlias
+
+__all__ = [
+    "TarFile",
+    "TarInfo",
+    "is_tarfile",
+    "TarError",
+    "ReadError",
+    "CompressionError",
+    "StreamError",
+    "ExtractError",
+    "HeaderError",
+    "ENCODING",
+    "USTAR_FORMAT",
+    "GNU_FORMAT",
+    "PAX_FORMAT",
+    "DEFAULT_FORMAT",
+    "open",
+]
+if sys.version_info >= (3, 12):
+    __all__ += [
+        "fully_trusted_filter",
+        "data_filter",
+        "tar_filter",
+        "FilterError",
+        "AbsoluteLinkError",
+        "OutsideDestinationError",
+        "SpecialFileError",
+        "AbsolutePathError",
+        "LinkOutsideDestinationError",
+    ]
+
+_FilterFunction: TypeAlias = Callable[[TarInfo, str], TarInfo | None]
+_TarfileFilter: TypeAlias = Literal["fully_trusted", "tar", "data"] | _FilterFunction
+
+class _Fileobj(Protocol):
+    def read(self, size: int, /) -> bytes: ...
+    def write(self, b: bytes, /) -> object: ...
+    def tell(self) -> int: ...
+    def seek(self, pos: int, /) -> object: ...
+    def close(self) -> object: ...
+    # Optional fields:
+    # name: str | bytes
+    # mode: Literal["rb", "r+b", "wb", "xb"]
+
+class _Bz2ReadableFileobj(bz2._ReadableFileobj):
+    def close(self) -> object: ...
+
+class _Bz2WritableFileobj(bz2._WritableFileobj):
+    def close(self) -> object: ...
+
+# tar constants
+NUL: bytes
+BLOCKSIZE: int
+RECORDSIZE: int
+GNU_MAGIC: bytes
+POSIX_MAGIC: bytes
+
+LENGTH_NAME: int
+LENGTH_LINK: int
+LENGTH_PREFIX: int
+
+REGTYPE: bytes
+AREGTYPE: bytes
+LNKTYPE: bytes
+SYMTYPE: bytes
+CONTTYPE: bytes
+BLKTYPE: bytes
+DIRTYPE: bytes
+FIFOTYPE: bytes
+CHRTYPE: bytes
+
+GNUTYPE_LONGNAME: bytes
+GNUTYPE_LONGLINK: bytes
+GNUTYPE_SPARSE: bytes
+
+XHDTYPE: bytes
+XGLTYPE: bytes
+SOLARIS_XHDTYPE: bytes
+
+USTAR_FORMAT: int
+GNU_FORMAT: int
+PAX_FORMAT: int
+DEFAULT_FORMAT: int
+
+# tarfile constants
+
+SUPPORTED_TYPES: tuple[bytes, ...]
+REGULAR_TYPES: tuple[bytes, ...]
+GNU_TYPES: tuple[bytes, ...]
+PAX_FIELDS: tuple[str, ...]
+PAX_NUMBER_FIELDS: dict[str, type]
+PAX_NAME_FIELDS: set[str]
+
+ENCODING: str
+
+def open(
+    name: StrOrBytesPath | None = None,
+    mode: str = "r",
+    fileobj: IO[bytes] | None = None,  # depends on mode
+    bufsize: int = 10240,
+    *,
+    format: int | None = ...,
+    tarinfo: type[TarInfo] | None = ...,
+    dereference: bool | None = ...,
+    ignore_zeros: bool | None = ...,
+    encoding: str | None = ...,
+    errors: str = ...,
+    pax_headers: Mapping[str, str] | None = ...,
+    debug: int | None = ...,
+    errorlevel: int | None = ...,
+    compresslevel: int | None = ...,
+    preset: Literal[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] | None = ...,
+) -> TarFile: ...
+
+class ExFileObject(io.BufferedReader):
+    def __init__(self, tarfile: TarFile, tarinfo: TarInfo) -> None: ...
+
+class TarFile:
+    OPEN_METH: ClassVar[Mapping[str, str]]
+    name: StrOrBytesPath | None
+    mode: Literal["r", "a", "w", "x"]
+    fileobj: _Fileobj | None
+    format: int | None
+    tarinfo: type[TarInfo]
+    dereference: bool | None
+    ignore_zeros: bool | None
+    encoding: str | None
+    errors: str
+    fileobject: type[ExFileObject]
+    pax_headers: Mapping[str, str] | None
+    debug: int | None
+    errorlevel: int | None
+    offset: int  # undocumented
+    extraction_filter: _FilterFunction | None
+    def __init__(
+        self,
+        name: StrOrBytesPath | None = None,
+        mode: Literal["r", "a", "w", "x"] = "r",
+        fileobj: _Fileobj | None = None,
+        format: int | None = None,
+        tarinfo: type[TarInfo] | None = None,
+        dereference: bool | None = None,
+        ignore_zeros: bool | None = None,
+        encoding: str | None = None,
+        errors: str = "surrogateescape",
+        pax_headers: Mapping[str, str] | None = None,
+        debug: int | None = None,
+        errorlevel: int | None = None,
+        copybufsize: int | None = None,  # undocumented
+    ) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
+    ) -> None: ...
+    def __iter__(self) -> Iterator[TarInfo]: ...
+    @classmethod
+    def open(
+        cls,
+        name: StrOrBytesPath | None = None,
+        mode: str = "r",
+        fileobj: IO[bytes] | None = None,  # depends on mode
+        bufsize: int = 10240,
+        *,
+        format: int | None = ...,
+        tarinfo: type[TarInfo] | None = ...,
+        dereference: bool | None = ...,
+        ignore_zeros: bool | None = ...,
+        encoding: str | None = ...,
+        errors: str = ...,
+        pax_headers: Mapping[str, str] | None = ...,
+        debug: int | None = ...,
+        errorlevel: int | None = ...,
+    ) -> Self: ...
+    @classmethod
+    def taropen(
+        cls,
+        name: StrOrBytesPath | None,
+        mode: Literal["r", "a", "w", "x"] = "r",
+        fileobj: _Fileobj | None = None,
+        *,
+        compresslevel: int = ...,
+        format: int | None = ...,
+        tarinfo: type[TarInfo] | None = ...,
+        dereference: bool | None = ...,
+        ignore_zeros: bool | None = ...,
+        encoding: str | None = ...,
+        pax_headers: Mapping[str, str] | None = ...,
+        debug: int | None = ...,
+        errorlevel: int | None = ...,
+    ) -> Self: ...
+    @overload
+    @classmethod
+    def gzopen(
+        cls,
+        name: StrOrBytesPath | None,
+        mode: Literal["r"] = "r",
+        fileobj: _GzipReadableFileobj | None = None,
+        compresslevel: int = 9,
+        *,
+        format: int | None = ...,
+        tarinfo: type[TarInfo] | None = ...,
+        dereference: bool | None = ...,
+        ignore_zeros: bool | None = ...,
+        encoding: str | None = ...,
+        pax_headers: Mapping[str, str] | None = ...,
+        debug: int | None = ...,
+        errorlevel: int | None = ...,
+    ) -> Self: ...
+    @overload
+    @classmethod
+    def gzopen(
+        cls,
+        name: StrOrBytesPath | None,
+        mode: Literal["w", "x"],
+        fileobj: _GzipWritableFileobj | None = None,
+        compresslevel: int = 9,
+        *,
+        format: int | None = ...,
+        tarinfo: type[TarInfo] | None = ...,
+        dereference: bool | None = ...,
+        ignore_zeros: bool | None = ...,
+        encoding: str | None = ...,
+        pax_headers: Mapping[str, str] | None = ...,
+        debug: int | None = ...,
+        errorlevel: int | None = ...,
+    ) -> Self: ...
+    @overload
+    @classmethod
+    def bz2open(
+        cls,
+        name: StrOrBytesPath | None,
+        mode: Literal["w", "x"],
+        fileobj: _Bz2WritableFileobj | None = None,
+        compresslevel: int = 9,
+        *,
+        format: int | None = ...,
+        tarinfo: type[TarInfo] | None = ...,
+        dereference: bool | None = ...,
+        ignore_zeros: bool | None = ...,
+        encoding: str | None = ...,
+        pax_headers: Mapping[str, str] | None = ...,
+        debug: int | None = ...,
+        errorlevel: int | None = ...,
+    ) -> Self: ...
+    @overload
+    @classmethod
+    def bz2open(
+        cls,
+        name: StrOrBytesPath | None,
+        mode: Literal["r"] = "r",
+        fileobj: _Bz2ReadableFileobj | None = None,
+        compresslevel: int = 9,
+        *,
+        format: int | None = ...,
+        tarinfo: type[TarInfo] | None = ...,
+        dereference: bool | None = ...,
+        ignore_zeros: bool | None = ...,
+        encoding: str | None = ...,
+        pax_headers: Mapping[str, str] | None = ...,
+        debug: int | None = ...,
+        errorlevel: int | None = ...,
+    ) -> Self: ...
+    @classmethod
+    def xzopen(
+        cls,
+        name: StrOrBytesPath | None,
+        mode: Literal["r", "w", "x"] = "r",
+        fileobj: IO[bytes] | None = None,
+        preset: int | None = None,
+        *,
+        format: int | None = ...,
+        tarinfo: type[TarInfo] | None = ...,
+        dereference: bool | None = ...,
+        ignore_zeros: bool | None = ...,
+        encoding: str | None = ...,
+        pax_headers: Mapping[str, str] | None = ...,
+        debug: int | None = ...,
+        errorlevel: int | None = ...,
+    ) -> Self: ...
+    def getmember(self, name: str) -> TarInfo: ...
+    def getmembers(self) -> _list[TarInfo]: ...
+    def getnames(self) -> _list[str]: ...
+    def list(self, verbose: bool = True, *, members: _list[TarInfo] | None = None) -> None: ...
+    def next(self) -> TarInfo | None: ...
+    # Calling this method without `filter` is deprecated, but it may be set either on the class or in an
+    # individual call, so we can't mark it as @deprecated here.
+    def extractall(
+        self,
+        path: StrOrBytesPath = ".",
+        members: Iterable[TarInfo] | None = None,
+        *,
+        numeric_owner: bool = False,
+        filter: _TarfileFilter | None = ...,
+    ) -> None: ...
+    # Same situation as for `extractall`.
+    def extract(
+        self,
+        member: str | TarInfo,
+        path: StrOrBytesPath = "",
+        set_attrs: bool = True,
+        *,
+        numeric_owner: bool = False,
+        filter: _TarfileFilter | None = ...,
+    ) -> None: ...
+    def _extract_member(
+        self, tarinfo: TarInfo, targetpath: str, set_attrs: bool = True, numeric_owner: bool = False
+    ) -> None: ...  # undocumented
+    def extractfile(self, member: str | TarInfo) -> IO[bytes] | None: ...
+    def makedir(self, tarinfo: TarInfo, targetpath: StrOrBytesPath) -> None: ...  # undocumented
+    def makefile(self, tarinfo: TarInfo, targetpath: StrOrBytesPath) -> None: ...  # undocumented
+    def makeunknown(self, tarinfo: TarInfo, targetpath: StrOrBytesPath) -> None: ...  # undocumented
+    def makefifo(self, tarinfo: TarInfo, targetpath: StrOrBytesPath) -> None: ...  # undocumented
+    def makedev(self, tarinfo: TarInfo, targetpath: StrOrBytesPath) -> None: ...  # undocumented
+    def makelink(self, tarinfo: TarInfo, targetpath: StrOrBytesPath) -> None: ...  # undocumented
+    def chown(self, tarinfo: TarInfo, targetpath: StrOrBytesPath, numeric_owner: bool) -> None: ...  # undocumented
+    def chmod(self, tarinfo: TarInfo, targetpath: StrOrBytesPath) -> None: ...  # undocumented
+    def utime(self, tarinfo: TarInfo, targetpath: StrOrBytesPath) -> None: ...  # undocumented
+    def add(
+        self,
+        name: StrPath,
+        arcname: StrPath | None = None,
+        recursive: bool = True,
+        *,
+        filter: Callable[[TarInfo], TarInfo | None] | None = None,
+    ) -> None: ...
+    def addfile(self, tarinfo: TarInfo, fileobj: IO[bytes] | None = None) -> None: ...
+    def gettarinfo(
+        self, name: StrOrBytesPath | None = None, arcname: str | None = None, fileobj: IO[bytes] | None = None
+    ) -> TarInfo: ...
+    def close(self) -> None: ...
+
+if sys.version_info >= (3, 9):
+    def is_tarfile(name: StrOrBytesPath | IO[bytes]) -> bool: ...
+
+else:
+    def is_tarfile(name: StrOrBytesPath) -> bool: ...
+
+class TarError(Exception): ...
+class ReadError(TarError): ...
+class CompressionError(TarError): ...
+class StreamError(TarError): ...
+class ExtractError(TarError): ...
+class HeaderError(TarError): ...
+
+class FilterError(TarError):
+    # This attribute is only set directly on the subclasses, but the documentation guarantees
+    # that it is always present on FilterError.
+    tarinfo: TarInfo
+
+class AbsolutePathError(FilterError):
+    def __init__(self, tarinfo: TarInfo) -> None: ...
+
+class OutsideDestinationError(FilterError):
+    def __init__(self, tarinfo: TarInfo, path: str) -> None: ...
+
+class SpecialFileError(FilterError):
+    def __init__(self, tarinfo: TarInfo) -> None: ...
+
+class AbsoluteLinkError(FilterError):
+    def __init__(self, tarinfo: TarInfo) -> None: ...
+
+class LinkOutsideDestinationError(FilterError):
+    def __init__(self, tarinfo: TarInfo, path: str) -> None: ...
+
+def fully_trusted_filter(member: TarInfo, dest_path: str) -> TarInfo: ...
+def tar_filter(member: TarInfo, dest_path: str) -> TarInfo: ...
+def data_filter(member: TarInfo, dest_path: str) -> TarInfo: ...
+
+class TarInfo:
+    name: str
+    path: str
+    size: int
+    mtime: int
+    chksum: int
+    devmajor: int
+    devminor: int
+    offset: int
+    offset_data: int
+    sparse: bytes | None
+    tarfile: TarFile | None
+    mode: int
+    type: bytes
+    linkname: str
+    uid: int
+    gid: int
+    uname: str
+    gname: str
+    pax_headers: Mapping[str, str]
+    def __init__(self, name: str = "") -> None: ...
+    @classmethod
+    def frombuf(cls, buf: bytes | bytearray, encoding: str, errors: str) -> Self: ...
+    @classmethod
+    def fromtarfile(cls, tarfile: TarFile) -> Self: ...
+    @property
+    def linkpath(self) -> str: ...
+    @linkpath.setter
+    def linkpath(self, linkname: str) -> None: ...
+    def replace(
+        self,
+        *,
+        name: str = ...,
+        mtime: int = ...,
+        mode: int = ...,
+        linkname: str = ...,
+        uid: int = ...,
+        gid: int = ...,
+        uname: str = ...,
+        gname: str = ...,
+        deep: bool = True,
+    ) -> Self: ...
+    def get_info(self) -> Mapping[str, str | int | bytes | Mapping[str, str]]: ...
+    def tobuf(self, format: int | None = 2, encoding: str | None = "utf-8", errors: str = "surrogateescape") -> bytes: ...
+    def create_ustar_header(
+        self, info: Mapping[str, str | int | bytes | Mapping[str, str]], encoding: str, errors: str
+    ) -> bytes: ...
+    def create_gnu_header(
+        self, info: Mapping[str, str | int | bytes | Mapping[str, str]], encoding: str, errors: str
+    ) -> bytes: ...
+    def create_pax_header(self, info: Mapping[str, str | int | bytes | Mapping[str, str]], encoding: str) -> bytes: ...
+    @classmethod
+    def create_pax_global_header(cls, pax_headers: Mapping[str, str]) -> bytes: ...
+    def isfile(self) -> bool: ...
+    def isreg(self) -> bool: ...
+    def issparse(self) -> bool: ...
+    def isdir(self) -> bool: ...
+    def issym(self) -> bool: ...
+    def islnk(self) -> bool: ...
+    def ischr(self) -> bool: ...
+    def isblk(self) -> bool: ...
+    def isfifo(self) -> bool: ...
+    def isdev(self) -> bool: ...

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

@@ -0,0 +1,122 @@
+import socket
+from collections.abc import Callable, Sequence
+from re import Match, Pattern
+from types import TracebackType
+from typing import Any
+from typing_extensions import Self
+
+__all__ = ["Telnet"]
+
+DEBUGLEVEL: int
+TELNET_PORT: int
+
+IAC: bytes
+DONT: bytes
+DO: bytes
+WONT: bytes
+WILL: bytes
+theNULL: bytes
+
+SE: bytes
+NOP: bytes
+DM: bytes
+BRK: bytes
+IP: bytes
+AO: bytes
+AYT: bytes
+EC: bytes
+EL: bytes
+GA: bytes
+SB: bytes
+
+BINARY: bytes
+ECHO: bytes
+RCP: bytes
+SGA: bytes
+NAMS: bytes
+STATUS: bytes
+TM: bytes
+RCTE: bytes
+NAOL: bytes
+NAOP: bytes
+NAOCRD: bytes
+NAOHTS: bytes
+NAOHTD: bytes
+NAOFFD: bytes
+NAOVTS: bytes
+NAOVTD: bytes
+NAOLFD: bytes
+XASCII: bytes
+LOGOUT: bytes
+BM: bytes
+DET: bytes
+SUPDUP: bytes
+SUPDUPOUTPUT: bytes
+SNDLOC: bytes
+TTYPE: bytes
+EOR: bytes
+TUID: bytes
+OUTMRK: bytes
+TTYLOC: bytes
+VT3270REGIME: bytes
+X3PAD: bytes
+NAWS: bytes
+TSPEED: bytes
+LFLOW: bytes
+LINEMODE: bytes
+XDISPLOC: bytes
+OLD_ENVIRON: bytes
+AUTHENTICATION: bytes
+ENCRYPT: bytes
+NEW_ENVIRON: bytes
+
+TN3270E: bytes
+XAUTH: bytes
+CHARSET: bytes
+RSP: bytes
+COM_PORT_OPTION: bytes
+SUPPRESS_LOCAL_ECHO: bytes
+TLS: bytes
+KERMIT: bytes
+SEND_URL: bytes
+FORWARD_X: bytes
+PRAGMA_LOGON: bytes
+SSPI_LOGON: bytes
+PRAGMA_HEARTBEAT: bytes
+EXOPL: bytes
+NOOPT: bytes
+
+class Telnet:
+    host: str | None  # undocumented
+    def __init__(self, host: str | None = None, port: int = 0, timeout: float = ...) -> None: ...
+    def open(self, host: str, port: int = 0, timeout: float = ...) -> None: ...
+    def msg(self, msg: str, *args: Any) -> None: ...
+    def set_debuglevel(self, debuglevel: int) -> None: ...
+    def close(self) -> None: ...
+    def get_socket(self) -> socket.socket: ...
+    def fileno(self) -> int: ...
+    def write(self, buffer: bytes) -> None: ...
+    def read_until(self, match: bytes, timeout: float | None = None) -> bytes: ...
+    def read_all(self) -> bytes: ...
+    def read_some(self) -> bytes: ...
+    def read_very_eager(self) -> bytes: ...
+    def read_eager(self) -> bytes: ...
+    def read_lazy(self) -> bytes: ...
+    def read_very_lazy(self) -> bytes: ...
+    def read_sb_data(self) -> bytes: ...
+    def set_option_negotiation_callback(self, callback: Callable[[socket.socket, bytes, bytes], object] | None) -> None: ...
+    def process_rawq(self) -> None: ...
+    def rawq_getchar(self) -> bytes: ...
+    def fill_rawq(self) -> None: ...
+    def sock_avail(self) -> bool: ...
+    def interact(self) -> None: ...
+    def mt_interact(self) -> None: ...
+    def listener(self) -> None: ...
+    def expect(
+        self, list: Sequence[Pattern[bytes] | bytes], timeout: float | None = None
+    ) -> tuple[int, Match[bytes] | None, bytes]: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
+    ) -> None: ...
+    def __del__(self) -> None: ...