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

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

@@ -0,0 +1,306 @@
+import email.message
+import io
+import sys
+from _typeshed import StrPath, SupportsNoArgReadline, SupportsRead
+from abc import ABCMeta, abstractmethod
+from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence
+from types import TracebackType
+from typing import IO, Any, AnyStr, Generic, Literal, Protocol, TypeVar, overload
+from typing_extensions import Self, TypeAlias
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+__all__ = [
+    "Mailbox",
+    "Maildir",
+    "mbox",
+    "MH",
+    "Babyl",
+    "MMDF",
+    "Message",
+    "MaildirMessage",
+    "mboxMessage",
+    "MHMessage",
+    "BabylMessage",
+    "MMDFMessage",
+    "Error",
+    "NoSuchMailboxError",
+    "NotEmptyError",
+    "ExternalClashError",
+    "FormatError",
+]
+
+_T = TypeVar("_T")
+_MessageT = TypeVar("_MessageT", bound=Message)
+
+class _SupportsReadAndReadline(
+    SupportsRead[bytes], SupportsNoArgReadline[bytes], Protocol
+): ...
+
+_MessageData: TypeAlias = (
+    email.message.Message | bytes | str | io.StringIO | _SupportsReadAndReadline
+)
+
+class _HasIteritems(Protocol):
+    def iteritems(self) -> Iterator[tuple[str, _MessageData]]: ...
+
+class _HasItems(Protocol):
+    def items(self) -> Iterator[tuple[str, _MessageData]]: ...
+
+linesep: bytes
+
+class Mailbox(Generic[_MessageT]):
+    _path: str  # undocumented
+    _factory: Callable[[IO[Any]], _MessageT] | None  # undocumented
+    @overload
+    def __init__(
+        self,
+        path: StrPath,
+        factory: Callable[[IO[Any]], _MessageT],
+        create: bool = True,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self, path: StrPath, factory: None = None, create: bool = True
+    ) -> None: ...
+    @abstractmethod
+    def add(self, message: _MessageData) -> str: ...
+    @abstractmethod
+    def remove(self, key: str) -> None: ...
+    def __delitem__(self, key: str) -> None: ...
+    def discard(self, key: str) -> None: ...
+    @abstractmethod
+    def __setitem__(self, key: str, message: _MessageData) -> None: ...
+    @overload
+    def get(self, key: str, default: None = None) -> _MessageT | None: ...
+    @overload
+    def get(self, key: str, default: _T) -> _MessageT | _T: ...
+    def __getitem__(self, key: str) -> _MessageT: ...
+    @abstractmethod
+    def get_message(self, key: str) -> _MessageT: ...
+    def get_string(self, key: str) -> str: ...
+    @abstractmethod
+    def get_bytes(self, key: str) -> bytes: ...
+    # As '_ProxyFile' doesn't implement the full IO spec, and BytesIO is incompatible with it, get_file return is Any here
+    @abstractmethod
+    def get_file(self, key: str) -> Any: ...
+    @abstractmethod
+    def iterkeys(self) -> Iterator[str]: ...
+    def keys(self) -> list[str]: ...
+    def itervalues(self) -> Iterator[_MessageT]: ...
+    def __iter__(self) -> Iterator[_MessageT]: ...
+    def values(self) -> list[_MessageT]: ...
+    def iteritems(self) -> Iterator[tuple[str, _MessageT]]: ...
+    def items(self) -> list[tuple[str, _MessageT]]: ...
+    @abstractmethod
+    def __contains__(self, key: str) -> bool: ...
+    @abstractmethod
+    def __len__(self) -> int: ...
+    def clear(self) -> None: ...
+    @overload
+    def pop(self, key: str, default: None = None) -> _MessageT | None: ...
+    @overload
+    def pop(self, key: str, default: _T) -> _MessageT | _T: ...
+    def popitem(self) -> tuple[str, _MessageT]: ...
+    def update(
+        self,
+        arg: (
+            _HasIteritems | _HasItems | Iterable[tuple[str, _MessageData]] | None
+        ) = None,
+    ) -> None: ...
+    @abstractmethod
+    def flush(self) -> None: ...
+    @abstractmethod
+    def lock(self) -> None: ...
+    @abstractmethod
+    def unlock(self) -> None: ...
+    @abstractmethod
+    def close(self) -> None: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+class Maildir(Mailbox[MaildirMessage]):
+    colon: str
+    def __init__(
+        self,
+        dirname: StrPath,
+        factory: Callable[[IO[Any]], MaildirMessage] | None = None,
+        create: bool = True,
+    ) -> None: ...
+    def add(self, message: _MessageData) -> str: ...
+    def remove(self, key: str) -> None: ...
+    def __setitem__(self, key: str, message: _MessageData) -> None: ...
+    def get_message(self, key: str) -> MaildirMessage: ...
+    def get_bytes(self, key: str) -> bytes: ...
+    def get_file(self, key: str) -> _ProxyFile[bytes]: ...
+    def iterkeys(self) -> Iterator[str]: ...
+    def __contains__(self, key: str) -> bool: ...
+    def __len__(self) -> int: ...
+    def flush(self) -> None: ...
+    def lock(self) -> None: ...
+    def unlock(self) -> None: ...
+    def close(self) -> None: ...
+    def list_folders(self) -> list[str]: ...
+    def get_folder(self, folder: str) -> Maildir: ...
+    def add_folder(self, folder: str) -> Maildir: ...
+    def remove_folder(self, folder: str) -> None: ...
+    def clean(self) -> None: ...
+    def next(self) -> str | None: ...
+
+class _singlefileMailbox(Mailbox[_MessageT], metaclass=ABCMeta):
+    def add(self, message: _MessageData) -> str: ...
+    def remove(self, key: str) -> None: ...
+    def __setitem__(self, key: str, message: _MessageData) -> None: ...
+    def iterkeys(self) -> Iterator[str]: ...
+    def __contains__(self, key: str) -> bool: ...
+    def __len__(self) -> int: ...
+    def lock(self) -> None: ...
+    def unlock(self) -> None: ...
+    def flush(self) -> None: ...
+    def close(self) -> None: ...
+
+class _mboxMMDF(_singlefileMailbox[_MessageT]):
+    def get_message(self, key: str) -> _MessageT: ...
+    def get_file(self, key: str, from_: bool = False) -> _PartialFile[bytes]: ...
+    def get_bytes(self, key: str, from_: bool = False) -> bytes: ...
+    def get_string(self, key: str, from_: bool = False) -> str: ...
+
+class mbox(_mboxMMDF[mboxMessage]):
+    def __init__(
+        self,
+        path: StrPath,
+        factory: Callable[[IO[Any]], mboxMessage] | None = None,
+        create: bool = True,
+    ) -> None: ...
+
+class MMDF(_mboxMMDF[MMDFMessage]):
+    def __init__(
+        self,
+        path: StrPath,
+        factory: Callable[[IO[Any]], MMDFMessage] | None = None,
+        create: bool = True,
+    ) -> None: ...
+
+class MH(Mailbox[MHMessage]):
+    def __init__(
+        self,
+        path: StrPath,
+        factory: Callable[[IO[Any]], MHMessage] | None = None,
+        create: bool = True,
+    ) -> None: ...
+    def add(self, message: _MessageData) -> str: ...
+    def remove(self, key: str) -> None: ...
+    def __setitem__(self, key: str, message: _MessageData) -> None: ...
+    def get_message(self, key: str) -> MHMessage: ...
+    def get_bytes(self, key: str) -> bytes: ...
+    def get_file(self, key: str) -> _ProxyFile[bytes]: ...
+    def iterkeys(self) -> Iterator[str]: ...
+    def __contains__(self, key: str) -> bool: ...
+    def __len__(self) -> int: ...
+    def flush(self) -> None: ...
+    def lock(self) -> None: ...
+    def unlock(self) -> None: ...
+    def close(self) -> None: ...
+    def list_folders(self) -> list[str]: ...
+    def get_folder(self, folder: StrPath) -> MH: ...
+    def add_folder(self, folder: StrPath) -> MH: ...
+    def remove_folder(self, folder: StrPath) -> None: ...
+    def get_sequences(self) -> dict[str, list[int]]: ...
+    def set_sequences(self, sequences: Mapping[str, Sequence[int]]) -> None: ...
+    def pack(self) -> None: ...
+
+class Babyl(_singlefileMailbox[BabylMessage]):
+    def __init__(
+        self,
+        path: StrPath,
+        factory: Callable[[IO[Any]], BabylMessage] | None = None,
+        create: bool = True,
+    ) -> None: ...
+    def get_message(self, key: str) -> BabylMessage: ...
+    def get_bytes(self, key: str) -> bytes: ...
+    def get_file(self, key: str) -> IO[bytes]: ...
+    def get_labels(self) -> list[str]: ...
+
+class Message(email.message.Message):
+    def __init__(self, message: _MessageData | None = None) -> None: ...
+
+class MaildirMessage(Message):
+    def get_subdir(self) -> str: ...
+    def set_subdir(self, subdir: Literal["new", "cur"]) -> None: ...
+    def get_flags(self) -> str: ...
+    def set_flags(self, flags: Iterable[str]) -> None: ...
+    def add_flag(self, flag: str) -> None: ...
+    def remove_flag(self, flag: str) -> None: ...
+    def get_date(self) -> int: ...
+    def set_date(self, date: float) -> None: ...
+    def get_info(self) -> str: ...
+    def set_info(self, info: str) -> None: ...
+
+class _mboxMMDFMessage(Message):
+    def get_from(self) -> str: ...
+    def set_from(
+        self,
+        from_: str,
+        time_: bool | tuple[int, int, int, int, int, int, int, int, int] | None = None,
+    ) -> None: ...
+    def get_flags(self) -> str: ...
+    def set_flags(self, flags: Iterable[str]) -> None: ...
+    def add_flag(self, flag: str) -> None: ...
+    def remove_flag(self, flag: str) -> None: ...
+
+class mboxMessage(_mboxMMDFMessage): ...
+
+class MHMessage(Message):
+    def get_sequences(self) -> list[str]: ...
+    def set_sequences(self, sequences: Iterable[str]) -> None: ...
+    def add_sequence(self, sequence: str) -> None: ...
+    def remove_sequence(self, sequence: str) -> None: ...
+
+class BabylMessage(Message):
+    def get_labels(self) -> list[str]: ...
+    def set_labels(self, labels: Iterable[str]) -> None: ...
+    def add_label(self, label: str) -> None: ...
+    def remove_label(self, label: str) -> None: ...
+    def get_visible(self) -> Message: ...
+    def set_visible(self, visible: _MessageData) -> None: ...
+    def update_visible(self) -> None: ...
+
+class MMDFMessage(_mboxMMDFMessage): ...
+
+class _ProxyFile(Generic[AnyStr]):
+    def __init__(self, f: IO[AnyStr], pos: int | None = None) -> None: ...
+    def read(self, size: int | None = None) -> AnyStr: ...
+    def read1(self, size: int | None = None) -> AnyStr: ...
+    def readline(self, size: int | None = None) -> AnyStr: ...
+    def readlines(self, sizehint: int | None = None) -> list[AnyStr]: ...
+    def __iter__(self) -> Iterator[AnyStr]: ...
+    def tell(self) -> int: ...
+    def seek(self, offset: int, whence: int = 0) -> None: ...
+    def close(self) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None: ...
+    def readable(self) -> bool: ...
+    def writable(self) -> bool: ...
+    def seekable(self) -> bool: ...
+    def flush(self) -> None: ...
+    @property
+    def closed(self) -> bool: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+class _PartialFile(_ProxyFile[AnyStr]):
+    def __init__(
+        self, f: IO[AnyStr], start: int | None = None, stop: int | None = None
+    ) -> None: ...
+
+class Error(Exception): ...
+class NoSuchMailboxError(Error): ...
+class NotEmptyError(Error): ...
+class ExternalClashError(Error): ...
+class FormatError(Error): ...

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

@@ -0,0 +1,15 @@
+from collections.abc import Mapping, Sequence
+from typing_extensions import TypeAlias
+
+_Cap: TypeAlias = dict[str, str | int]
+
+__all__ = ["getcaps", "findmatch"]
+
+def findmatch(
+    caps: Mapping[str, list[_Cap]],
+    MIMEtype: str,
+    key: str = "view",
+    filename: str = "/dev/null",
+    plist: Sequence[str] = [],
+) -> tuple[str | None, _Cap | None]: ...
+def getcaps() -> dict[str, list[_Cap]]: ...

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

@@ -0,0 +1,35 @@
+import builtins
+import types
+from _typeshed import ReadableBuffer, SupportsRead, SupportsWrite
+from typing import Any
+from typing_extensions import TypeAlias
+
+version: int
+
+_Marshallable: TypeAlias = (
+    # handled in w_object() in marshal.c
+    None
+    | type[StopIteration]
+    | builtins.ellipsis
+    | bool
+    # handled in w_complex_object() in marshal.c
+    | int
+    | float
+    | complex
+    | bytes
+    | str
+    | tuple[_Marshallable, ...]
+    | list[Any]
+    | dict[Any, Any]
+    | set[Any]
+    | frozenset[_Marshallable]
+    | types.CodeType
+    | ReadableBuffer
+)
+
+def dump(
+    __value: _Marshallable, __file: SupportsWrite[bytes], __version: int = 4
+) -> None: ...
+def load(__file: SupportsRead[bytes]) -> Any: ...
+def dumps(__value: _Marshallable, __version: int = 4) -> bytes: ...
+def loads(__bytes: ReadableBuffer) -> Any: ...

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

@@ -0,0 +1,134 @@
+import sys
+from collections.abc import Iterable
+from typing import Protocol, SupportsFloat, SupportsIndex, TypeVar, overload
+from typing_extensions import TypeAlias
+
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
+
+_SupportsFloatOrIndex: TypeAlias = SupportsFloat | SupportsIndex
+
+e: float
+pi: float
+inf: float
+nan: float
+tau: float
+
+def acos(__x: _SupportsFloatOrIndex) -> float: ...
+def acosh(__x: _SupportsFloatOrIndex) -> float: ...
+def asin(__x: _SupportsFloatOrIndex) -> float: ...
+def asinh(__x: _SupportsFloatOrIndex) -> float: ...
+def atan(__x: _SupportsFloatOrIndex) -> float: ...
+def atan2(__y: _SupportsFloatOrIndex, __x: _SupportsFloatOrIndex) -> float: ...
+def atanh(__x: _SupportsFloatOrIndex) -> float: ...
+
+if sys.version_info >= (3, 11):
+    def cbrt(__x: _SupportsFloatOrIndex) -> float: ...
+
+class _SupportsCeil(Protocol[_T_co]):
+    def __ceil__(self) -> _T_co: ...
+
+@overload
+def ceil(__x: _SupportsCeil[_T]) -> _T: ...
+@overload
+def ceil(__x: _SupportsFloatOrIndex) -> int: ...
+def comb(__n: SupportsIndex, __k: SupportsIndex) -> int: ...
+def copysign(__x: _SupportsFloatOrIndex, __y: _SupportsFloatOrIndex) -> float: ...
+def cos(__x: _SupportsFloatOrIndex) -> float: ...
+def cosh(__x: _SupportsFloatOrIndex) -> float: ...
+def degrees(__x: _SupportsFloatOrIndex) -> float: ...
+def dist(
+    __p: Iterable[_SupportsFloatOrIndex], __q: Iterable[_SupportsFloatOrIndex]
+) -> float: ...
+def erf(__x: _SupportsFloatOrIndex) -> float: ...
+def erfc(__x: _SupportsFloatOrIndex) -> float: ...
+def exp(__x: _SupportsFloatOrIndex) -> float: ...
+
+if sys.version_info >= (3, 11):
+    def exp2(__x: _SupportsFloatOrIndex) -> float: ...
+
+def expm1(__x: _SupportsFloatOrIndex) -> float: ...
+def fabs(__x: _SupportsFloatOrIndex) -> float: ...
+def factorial(__x: SupportsIndex) -> int: ...
+
+class _SupportsFloor(Protocol[_T_co]):
+    def __floor__(self) -> _T_co: ...
+
+@overload
+def floor(__x: _SupportsFloor[_T]) -> _T: ...
+@overload
+def floor(__x: _SupportsFloatOrIndex) -> int: ...
+def fmod(__x: _SupportsFloatOrIndex, __y: _SupportsFloatOrIndex) -> float: ...
+def frexp(__x: _SupportsFloatOrIndex) -> tuple[float, int]: ...
+def fsum(__seq: Iterable[_SupportsFloatOrIndex]) -> float: ...
+def gamma(__x: _SupportsFloatOrIndex) -> float: ...
+
+if sys.version_info >= (3, 9):
+    def gcd(*integers: SupportsIndex) -> int: ...
+
+else:
+    def gcd(__x: SupportsIndex, __y: SupportsIndex) -> int: ...
+
+def hypot(*coordinates: _SupportsFloatOrIndex) -> float: ...
+def isclose(
+    a: _SupportsFloatOrIndex,
+    b: _SupportsFloatOrIndex,
+    *,
+    rel_tol: _SupportsFloatOrIndex = 1e-09,
+    abs_tol: _SupportsFloatOrIndex = 0.0,
+) -> bool: ...
+def isinf(__x: _SupportsFloatOrIndex) -> bool: ...
+def isfinite(__x: _SupportsFloatOrIndex) -> bool: ...
+def isnan(__x: _SupportsFloatOrIndex) -> bool: ...
+def isqrt(__n: SupportsIndex) -> int: ...
+
+if sys.version_info >= (3, 9):
+    def lcm(*integers: SupportsIndex) -> int: ...
+
+def ldexp(__x: _SupportsFloatOrIndex, __i: int) -> float: ...
+def lgamma(__x: _SupportsFloatOrIndex) -> float: ...
+def log(x: _SupportsFloatOrIndex, base: _SupportsFloatOrIndex = ...) -> float: ...
+def log10(__x: _SupportsFloatOrIndex) -> float: ...
+def log1p(__x: _SupportsFloatOrIndex) -> float: ...
+def log2(__x: _SupportsFloatOrIndex) -> float: ...
+def modf(__x: _SupportsFloatOrIndex) -> tuple[float, float]: ...
+
+if sys.version_info >= (3, 12):
+    def nextafter(
+        __x: _SupportsFloatOrIndex,
+        __y: _SupportsFloatOrIndex,
+        *,
+        steps: SupportsIndex | None = None,
+    ) -> float: ...
+
+elif sys.version_info >= (3, 9):
+    def nextafter(__x: _SupportsFloatOrIndex, __y: _SupportsFloatOrIndex) -> float: ...
+
+def perm(__n: SupportsIndex, __k: SupportsIndex | None = None) -> int: ...
+def pow(__x: _SupportsFloatOrIndex, __y: _SupportsFloatOrIndex) -> float: ...
+@overload
+def prod(__iterable: Iterable[SupportsIndex], *, start: SupportsIndex = 1) -> int: ...  # type: ignore[overload-overlap]
+@overload
+def prod(
+    __iterable: Iterable[_SupportsFloatOrIndex], *, start: _SupportsFloatOrIndex = 1
+) -> float: ...
+def radians(__x: _SupportsFloatOrIndex) -> float: ...
+def remainder(__x: _SupportsFloatOrIndex, __y: _SupportsFloatOrIndex) -> float: ...
+def sin(__x: _SupportsFloatOrIndex) -> float: ...
+def sinh(__x: _SupportsFloatOrIndex) -> float: ...
+
+if sys.version_info >= (3, 12):
+    def sumprod(__p: Iterable[float], __q: Iterable[float]) -> float: ...
+
+def sqrt(__x: _SupportsFloatOrIndex) -> float: ...
+def tan(__x: _SupportsFloatOrIndex) -> float: ...
+def tanh(__x: _SupportsFloatOrIndex) -> float: ...
+
+# Is different from `_typeshed.SupportsTrunc`, which is not generic
+class _SupportsTrunc(Protocol[_T_co]):
+    def __trunc__(self) -> _T_co: ...
+
+def trunc(__x: _SupportsTrunc[_T]) -> _T: ...
+
+if sys.version_info >= (3, 9):
+    def ulp(__x: _SupportsFloatOrIndex) -> float: ...

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

@@ -0,0 +1,50 @@
+from _typeshed import StrPath
+from collections.abc import Sequence
+from typing import IO
+
+__all__ = [
+    "knownfiles",
+    "inited",
+    "MimeTypes",
+    "guess_type",
+    "guess_all_extensions",
+    "guess_extension",
+    "add_type",
+    "init",
+    "read_mime_types",
+    "suffix_map",
+    "encodings_map",
+    "types_map",
+    "common_types",
+]
+
+def guess_type(url: StrPath, strict: bool = True) -> tuple[str | None, str | None]: ...
+def guess_all_extensions(type: str, strict: bool = True) -> list[str]: ...
+def guess_extension(type: str, strict: bool = True) -> str | None: ...
+def init(files: Sequence[str] | None = None) -> None: ...
+def read_mime_types(file: str) -> dict[str, str] | None: ...
+def add_type(type: str, ext: str, strict: bool = True) -> None: ...
+
+inited: bool
+knownfiles: list[str]
+suffix_map: dict[str, str]
+encodings_map: dict[str, str]
+types_map: dict[str, str]
+common_types: dict[str, str]
+
+class MimeTypes:
+    suffix_map: dict[str, str]
+    encodings_map: dict[str, str]
+    types_map: tuple[dict[str, str], dict[str, str]]
+    types_map_inv: tuple[dict[str, str], dict[str, str]]
+    def __init__(
+        self, filenames: tuple[str, ...] = (), strict: bool = True
+    ) -> None: ...
+    def guess_extension(self, type: str, strict: bool = True) -> str | None: ...
+    def guess_type(
+        self, url: StrPath, strict: bool = True
+    ) -> tuple[str | None, str | None]: ...
+    def guess_all_extensions(self, type: str, strict: bool = True) -> list[str]: ...
+    def read(self, filename: str, strict: bool = True) -> None: ...
+    def readfp(self, fp: IO[str], strict: bool = True) -> None: ...
+    def read_windows_registry(self, strict: bool = True) -> None: ...

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

@@ -0,0 +1,126 @@
+import sys
+from _typeshed import ReadableBuffer, Unused
+from collections.abc import Iterable, Iterator, Sized
+from typing import NoReturn, overload
+from typing_extensions import Self
+
+ACCESS_DEFAULT: int
+ACCESS_READ: int
+ACCESS_WRITE: int
+ACCESS_COPY: int
+
+ALLOCATIONGRANULARITY: int
+
+if sys.platform == "linux":
+    MAP_DENYWRITE: int
+    MAP_EXECUTABLE: int
+    if sys.version_info >= (3, 10):
+        MAP_POPULATE: int
+if sys.version_info >= (3, 11) and sys.platform != "win32" and sys.platform != "darwin":
+    MAP_STACK: int
+
+if sys.platform != "win32":
+    MAP_ANON: int
+    MAP_ANONYMOUS: int
+    MAP_PRIVATE: int
+    MAP_SHARED: int
+    PROT_EXEC: int
+    PROT_READ: int
+    PROT_WRITE: int
+
+PAGESIZE: int
+
+class mmap(Iterable[int], Sized):
+    if sys.platform == "win32":
+        def __init__(
+            self,
+            fileno: int,
+            length: int,
+            tagname: str | None = ...,
+            access: int = ...,
+            offset: int = ...,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            fileno: int,
+            length: int,
+            flags: int = ...,
+            prot: int = ...,
+            access: int = ...,
+            offset: int = ...,
+        ) -> None: ...
+
+    def close(self) -> None: ...
+    def flush(self, offset: int = ..., size: int = ...) -> None: ...
+    def move(self, dest: int, src: int, count: int) -> None: ...
+    def read_byte(self) -> int: ...
+    def readline(self) -> bytes: ...
+    def resize(self, newsize: int) -> None: ...
+    def seek(self, pos: int, whence: int = ...) -> None: ...
+    def size(self) -> int: ...
+    def tell(self) -> int: ...
+    def write_byte(self, byte: int) -> None: ...
+    def __len__(self) -> int: ...
+    closed: bool
+    if sys.platform != "win32":
+        def madvise(self, option: int, start: int = ..., length: int = ...) -> None: ...
+
+    def find(self, sub: ReadableBuffer, start: int = ..., stop: int = ...) -> int: ...
+    def rfind(self, sub: ReadableBuffer, start: int = ..., stop: int = ...) -> int: ...
+    def read(self, n: int | None = ...) -> bytes: ...
+    def write(self, bytes: ReadableBuffer) -> int: ...
+    @overload
+    def __getitem__(self, __key: int) -> int: ...
+    @overload
+    def __getitem__(self, __key: slice) -> bytes: ...
+    def __delitem__(self, __key: int | slice) -> NoReturn: ...
+    @overload
+    def __setitem__(self, __key: int, __value: int) -> None: ...
+    @overload
+    def __setitem__(self, __key: slice, __value: ReadableBuffer) -> None: ...
+    # Doesn't actually exist, but the object actually supports "in" because it has __getitem__,
+    # so we claim that there is also a __contains__ to help type checkers.
+    def __contains__(self, __o: object) -> bool: ...
+    # Doesn't actually exist, but the object is actually iterable because it has __getitem__ and __len__,
+    # so we claim that there is also an __iter__ to help type checkers.
+    def __iter__(self) -> Iterator[int]: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(self, *args: Unused) -> None: ...
+    def __buffer__(self, __flags: int) -> memoryview: ...
+    def __release_buffer__(self, __buffer: memoryview) -> None: ...
+
+if sys.platform != "win32":
+    MADV_NORMAL: int
+    MADV_RANDOM: int
+    MADV_SEQUENTIAL: int
+    MADV_WILLNEED: int
+    MADV_DONTNEED: int
+    MADV_FREE: int
+
+if sys.platform == "linux":
+    MADV_REMOVE: int
+    MADV_DONTFORK: int
+    MADV_DOFORK: int
+    MADV_HWPOISON: int
+    MADV_MERGEABLE: int
+    MADV_UNMERGEABLE: int
+    # Seems like this constant is not defined in glibc.
+    # See https://github.com/python/typeshed/pull/5360 for details
+    # MADV_SOFT_OFFLINE: int
+    MADV_HUGEPAGE: int
+    MADV_NOHUGEPAGE: int
+    MADV_DONTDUMP: int
+    MADV_DODUMP: int
+
+# This Values are defined for FreeBSD but type checkers do not support conditions for these
+if sys.platform != "linux" and sys.platform != "darwin" and sys.platform != "win32":
+    MADV_NOSYNC: int
+    MADV_AUTOSYNC: int
+    MADV_NOCORE: int
+    MADV_CORE: int
+    MADV_PROTECT: int
+
+if sys.version_info >= (3, 10) and sys.platform == "darwin":
+    MADV_FREE_REUSABLE: int
+    MADV_FREE_REUSE: int