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

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

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

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

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

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

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

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

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