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

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

@@ -0,0 +1,256 @@
+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,11 @@
+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,33 @@
+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,125 @@
+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,46 @@
+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,113 @@
+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

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

@@ -0,0 +1,66 @@
+import sys
+from collections.abc import Container, Iterable, Iterator, Sequence
+from types import CodeType
+from typing import IO, Any
+
+if sys.version_info < (3, 11):
+    LOAD_CONST: int  # undocumented
+    IMPORT_NAME: int  # undocumented
+    STORE_NAME: int  # undocumented
+    STORE_GLOBAL: int  # undocumented
+    STORE_OPS: tuple[int, int]  # undocumented
+    EXTENDED_ARG: int  # undocumented
+
+packagePathMap: dict[str, list[str]]  # undocumented
+
+def AddPackagePath(packagename: str, path: str) -> None: ...
+
+replacePackageMap: dict[str, str]  # undocumented
+
+def ReplacePackage(oldname: str, newname: str) -> None: ...
+
+class Module:  # undocumented
+    def __init__(self, name: str, file: str | None = None, path: str | None = None) -> None: ...
+
+class ModuleFinder:
+    modules: dict[str, Module]
+    path: list[str]  # undocumented
+    badmodules: dict[str, dict[str, int]]  # undocumented
+    debug: int  # undocumented
+    indent: int  # undocumented
+    excludes: Container[str]  # undocumented
+    replace_paths: Sequence[tuple[str, str]]  # undocumented
+
+    def __init__(
+        self,
+        path: list[str] | None = None,
+        debug: int = 0,
+        excludes: Container[str] | None = None,
+        replace_paths: Sequence[tuple[str, str]] | None = None,
+    ) -> None: ...
+    def msg(self, level: int, str: str, *args: Any) -> None: ...  # undocumented
+    def msgin(self, *args: Any) -> None: ...  # undocumented
+    def msgout(self, *args: Any) -> None: ...  # undocumented
+    def run_script(self, pathname: str) -> None: ...
+    def load_file(self, pathname: str) -> None: ...  # undocumented
+    def import_hook(
+        self, name: str, caller: Module | None = None, fromlist: list[str] | None = None, level: int = -1
+    ) -> Module | None: ...  # undocumented
+    def determine_parent(self, caller: Module | None, level: int = -1) -> Module | None: ...  # undocumented
+    def find_head_package(self, parent: Module, name: str) -> tuple[Module, str]: ...  # undocumented
+    def load_tail(self, q: Module, tail: str) -> Module: ...  # undocumented
+    def ensure_fromlist(self, m: Module, fromlist: Iterable[str], recursive: int = 0) -> None: ...  # undocumented
+    def find_all_submodules(self, m: Module) -> Iterable[str]: ...  # undocumented
+    def import_module(self, partname: str, fqname: str, parent: Module) -> Module | None: ...  # undocumented
+    def load_module(self, fqname: str, fp: IO[str], pathname: str, file_info: tuple[str, str, str]) -> Module: ...  # undocumented
+    def scan_opcodes(self, co: CodeType) -> Iterator[tuple[str, tuple[Any, ...]]]: ...  # undocumented
+    def scan_code(self, co: CodeType, m: Module) -> None: ...  # undocumented
+    def load_package(self, fqname: str, pathname: str) -> Module: ...  # undocumented
+    def add_module(self, fqname: str) -> Module: ...  # undocumented
+    def find_module(
+        self, name: str, path: str | None, parent: Module | None = None
+    ) -> tuple[IO[Any] | None, str | None, tuple[str, str, int]]: ...  # undocumented
+    def report(self) -> None: ...
+    def any_missing(self) -> list[str]: ...  # undocumented
+    def any_missing_maybe(self) -> tuple[list[str], list[str]]: ...  # undocumented
+    def replace_paths_in_code(self, co: CodeType) -> CodeType: ...  # undocumented