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

jaclang/vendor/mypy/typeshed/stdlib/zipfile/__init__.pyi

@@ -0,0 +1,306 @@
+import io
+import sys
+from _typeshed import SizedBuffer, StrOrBytesPath, StrPath
+from collections.abc import Callable, Iterable, Iterator
+from io import TextIOWrapper
+from os import PathLike
+from types import TracebackType
+from typing import IO, Literal, Protocol, overload
+from typing_extensions import Self, TypeAlias
+
+__all__ = [
+    "BadZipFile",
+    "BadZipfile",
+    "Path",
+    "error",
+    "ZIP_STORED",
+    "ZIP_DEFLATED",
+    "ZIP_BZIP2",
+    "ZIP_LZMA",
+    "is_zipfile",
+    "ZipInfo",
+    "ZipFile",
+    "PyZipFile",
+    "LargeZipFile",
+]
+
+# TODO: use TypeAlias for these two when mypy bugs are fixed
+# https://github.com/python/mypy/issues/16581
+_DateTuple = tuple[int, int, int, int, int, int]  # noqa: Y026
+_ZipFileMode = Literal["r", "w", "x", "a"]  # noqa: Y026
+
+_ReadWriteMode: TypeAlias = Literal["r", "w"]
+_ReadWriteBinaryMode: TypeAlias = Literal["r", "w", "rb", "wb"]
+
+class BadZipFile(Exception): ...
+
+BadZipfile = BadZipFile
+error = BadZipfile
+
+class LargeZipFile(Exception): ...
+
+class _ZipStream(Protocol):
+    def read(self, n: int, /) -> bytes: ...
+    # The following methods are optional:
+    # def seekable(self) -> bool: ...
+    # def tell(self) -> int: ...
+    # def seek(self, n: int, /) -> object: ...
+
+# Stream shape as required by _EndRecData() and _EndRecData64().
+class _SupportsReadSeekTell(Protocol):
+    def read(self, n: int = ..., /) -> bytes: ...
+    def seek(self, cookie: int, whence: int, /) -> object: ...
+    def tell(self) -> int: ...
+
+class _ClosableZipStream(_ZipStream, Protocol):
+    def close(self) -> object: ...
+
+class ZipExtFile(io.BufferedIOBase):
+    MAX_N: int
+    MIN_READ_SIZE: int
+    MAX_SEEK_READ: int
+    newlines: list[bytes] | None
+    mode: _ReadWriteMode
+    name: str
+    @overload
+    def __init__(
+        self, fileobj: _ClosableZipStream, mode: _ReadWriteMode, zipinfo: ZipInfo, pwd: bytes | None, close_fileobj: Literal[True]
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        fileobj: _ClosableZipStream,
+        mode: _ReadWriteMode,
+        zipinfo: ZipInfo,
+        pwd: bytes | None = None,
+        *,
+        close_fileobj: Literal[True],
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        fileobj: _ZipStream,
+        mode: _ReadWriteMode,
+        zipinfo: ZipInfo,
+        pwd: bytes | None = None,
+        close_fileobj: Literal[False] = False,
+    ) -> None: ...
+    def read(self, n: int | None = -1) -> bytes: ...
+    def readline(self, limit: int = -1) -> bytes: ...  # type: ignore[override]
+    def peek(self, n: int = 1) -> bytes: ...
+    def read1(self, n: int | None) -> bytes: ...  # type: ignore[override]
+    def seek(self, offset: int, whence: int = 0) -> int: ...
+
+class _Writer(Protocol):
+    def write(self, s: str, /) -> object: ...
+
+class ZipFile:
+    filename: str | None
+    debug: int
+    comment: bytes
+    filelist: list[ZipInfo]
+    fp: IO[bytes] | None
+    NameToInfo: dict[str, ZipInfo]
+    start_dir: int  # undocumented
+    compression: int  # undocumented
+    compresslevel: int | None  # undocumented
+    mode: _ZipFileMode  # undocumented
+    pwd: bytes | None  # undocumented
+    if sys.version_info >= (3, 11):
+        @overload
+        def __init__(
+            self,
+            file: StrPath | IO[bytes],
+            mode: Literal["r"] = "r",
+            compression: int = 0,
+            allowZip64: bool = True,
+            compresslevel: int | None = None,
+            *,
+            strict_timestamps: bool = True,
+            metadata_encoding: str | None,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            file: StrPath | IO[bytes],
+            mode: _ZipFileMode = "r",
+            compression: int = 0,
+            allowZip64: bool = True,
+            compresslevel: int | None = None,
+            *,
+            strict_timestamps: bool = True,
+            metadata_encoding: None = None,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            file: StrPath | IO[bytes],
+            mode: _ZipFileMode = "r",
+            compression: int = 0,
+            allowZip64: bool = True,
+            compresslevel: int | None = None,
+            *,
+            strict_timestamps: bool = True,
+        ) -> None: ...
+
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
+    ) -> None: ...
+    def close(self) -> None: ...
+    def getinfo(self, name: str) -> ZipInfo: ...
+    def infolist(self) -> list[ZipInfo]: ...
+    def namelist(self) -> list[str]: ...
+    def open(
+        self, name: str | ZipInfo, mode: _ReadWriteMode = "r", pwd: bytes | None = None, *, force_zip64: bool = False
+    ) -> IO[bytes]: ...
+    def extract(self, member: str | ZipInfo, path: StrPath | None = None, pwd: bytes | None = None) -> str: ...
+    def extractall(
+        self, path: StrPath | None = None, members: Iterable[str | ZipInfo] | None = None, pwd: bytes | None = None
+    ) -> None: ...
+    def printdir(self, file: _Writer | None = None) -> None: ...
+    def setpassword(self, pwd: bytes) -> None: ...
+    def read(self, name: str | ZipInfo, pwd: bytes | None = None) -> bytes: ...
+    def testzip(self) -> str | None: ...
+    def write(
+        self,
+        filename: StrPath,
+        arcname: StrPath | None = None,
+        compress_type: int | None = None,
+        compresslevel: int | None = None,
+    ) -> None: ...
+    def writestr(
+        self,
+        zinfo_or_arcname: str | ZipInfo,
+        data: SizedBuffer | str,
+        compress_type: int | None = None,
+        compresslevel: int | None = None,
+    ) -> None: ...
+    if sys.version_info >= (3, 11):
+        def mkdir(self, zinfo_or_directory_name: str | ZipInfo, mode: int = 0o777) -> None: ...
+
+    def __del__(self) -> None: ...
+
+class PyZipFile(ZipFile):
+    def __init__(
+        self, file: str | IO[bytes], mode: _ZipFileMode = "r", compression: int = 0, allowZip64: bool = True, optimize: int = -1
+    ) -> None: ...
+    def writepy(self, pathname: str, basename: str = "", filterfunc: Callable[[str], bool] | None = None) -> None: ...
+
+class ZipInfo:
+    filename: str
+    date_time: _DateTuple
+    compress_type: int
+    comment: bytes
+    extra: bytes
+    create_system: int
+    create_version: int
+    extract_version: int
+    reserved: int
+    flag_bits: int
+    volume: int
+    internal_attr: int
+    external_attr: int
+    header_offset: int
+    CRC: int
+    compress_size: int
+    file_size: int
+    orig_filename: str  # undocumented
+    def __init__(self, filename: str = "NoName", date_time: _DateTuple = (1980, 1, 1, 0, 0, 0)) -> None: ...
+    @classmethod
+    def from_file(cls, filename: StrPath, arcname: StrPath | None = None, *, strict_timestamps: bool = True) -> Self: ...
+    def is_dir(self) -> bool: ...
+    def FileHeader(self, zip64: bool | None = None) -> bytes: ...
+
+if sys.version_info >= (3, 12):
+    from zipfile._path import CompleteDirs as CompleteDirs, Path as Path
+
+else:
+    class CompleteDirs(ZipFile):
+        def resolve_dir(self, name: str) -> str: ...
+        @overload
+        @classmethod
+        def make(cls, source: ZipFile) -> CompleteDirs: ...
+        @overload
+        @classmethod
+        def make(cls, source: StrPath | IO[bytes]) -> Self: ...
+
+    class Path:
+        root: CompleteDirs
+        def __init__(self, root: ZipFile | StrPath | IO[bytes], at: str = "") -> None: ...
+        @property
+        def name(self) -> str: ...
+        @property
+        def parent(self) -> PathLike[str]: ...  # undocumented
+        if sys.version_info >= (3, 10):
+            @property
+            def filename(self) -> PathLike[str]: ...  # undocumented
+        if sys.version_info >= (3, 11):
+            @property
+            def suffix(self) -> str: ...
+            @property
+            def suffixes(self) -> list[str]: ...
+            @property
+            def stem(self) -> str: ...
+
+        if sys.version_info >= (3, 9):
+            @overload
+            def open(
+                self,
+                mode: Literal["r", "w"] = "r",
+                encoding: str | None = None,
+                errors: str | None = None,
+                newline: str | None = None,
+                line_buffering: bool = ...,
+                write_through: bool = ...,
+                *,
+                pwd: bytes | None = None,
+            ) -> TextIOWrapper: ...
+            @overload
+            def open(self, mode: Literal["rb", "wb"], *, pwd: bytes | None = None) -> IO[bytes]: ...
+        else:
+            def open(
+                self, mode: _ReadWriteBinaryMode = "r", pwd: bytes | None = None, *, force_zip64: bool = False
+            ) -> IO[bytes]: ...
+
+        if sys.version_info >= (3, 10):
+            def iterdir(self) -> Iterator[Self]: ...
+        else:
+            def iterdir(self) -> Iterator[Path]: ...
+
+        def is_dir(self) -> bool: ...
+        def is_file(self) -> bool: ...
+        def exists(self) -> bool: ...
+        def read_text(
+            self,
+            encoding: str | None = ...,
+            errors: str | None = ...,
+            newline: str | None = ...,
+            line_buffering: bool = ...,
+            write_through: bool = ...,
+        ) -> str: ...
+        def read_bytes(self) -> bytes: ...
+        if sys.version_info >= (3, 10):
+            def joinpath(self, *other: StrPath) -> Path: ...
+        else:
+            def joinpath(self, add: StrPath) -> Path: ...  # undocumented
+        if sys.version_info >= (3, 12):
+            def glob(self, pattern: str) -> Iterator[Self]: ...
+            def rglob(self, pattern: str) -> Iterator[Self]: ...
+            def is_symlink(self) -> Literal[False]: ...
+            def relative_to(self, other: Path, *extra: StrPath) -> str: ...
+            def match(self, path_pattern: str) -> bool: ...
+            def __eq__(self, other: object) -> bool: ...
+            def __hash__(self) -> int: ...
+
+        def __truediv__(self, add: StrPath) -> Path: ...
+
+def is_zipfile(filename: StrOrBytesPath | _SupportsReadSeekTell) -> bool: ...
+
+ZIP_STORED: int
+ZIP_DEFLATED: int
+ZIP64_LIMIT: int
+ZIP_FILECOUNT_LIMIT: int
+ZIP_MAX_COMMENT: int
+ZIP_BZIP2: int
+ZIP_LZMA: int

jaclang/vendor/mypy/typeshed/stdlib/zipfile/_path.pyi

@@ -0,0 +1,95 @@
+import sys
+from _typeshed import StrPath
+from collections.abc import Iterator, Sequence
+from io import TextIOWrapper
+from os import PathLike
+from typing import IO, Literal, overload
+from typing_extensions import Self, TypeAlias
+from zipfile import ZipFile
+
+_ReadWriteBinaryMode: TypeAlias = Literal["r", "w", "rb", "wb"]
+
+if sys.version_info >= (3, 12):
+    class InitializedState:
+        def __init__(self, *args: object, **kwargs: object) -> None: ...
+        def __getstate__(self) -> tuple[list[object], dict[object, object]]: ...
+        def __setstate__(self, state: Sequence[tuple[list[object], dict[object, object]]]) -> None: ...
+
+    class CompleteDirs(InitializedState, ZipFile):
+        def resolve_dir(self, name: str) -> str: ...
+        @overload
+        @classmethod
+        def make(cls, source: ZipFile) -> CompleteDirs: ...
+        @overload
+        @classmethod
+        def make(cls, source: StrPath | IO[bytes]) -> Self: ...
+
+    class Path:
+        root: CompleteDirs
+        def __init__(self, root: ZipFile | StrPath | IO[bytes], at: str = "") -> None: ...
+        @property
+        def name(self) -> str: ...
+        @property
+        def parent(self) -> PathLike[str]: ...  # undocumented
+        if sys.version_info >= (3, 10):
+            @property
+            def filename(self) -> PathLike[str]: ...  # undocumented
+        if sys.version_info >= (3, 11):
+            @property
+            def suffix(self) -> str: ...
+            @property
+            def suffixes(self) -> list[str]: ...
+            @property
+            def stem(self) -> str: ...
+
+        if sys.version_info >= (3, 9):
+            @overload
+            def open(
+                self,
+                mode: Literal["r", "w"] = "r",
+                encoding: str | None = None,
+                errors: str | None = None,
+                newline: str | None = None,
+                line_buffering: bool = ...,
+                write_through: bool = ...,
+                *,
+                pwd: bytes | None = None,
+            ) -> TextIOWrapper: ...
+            @overload
+            def open(self, mode: Literal["rb", "wb"], *, pwd: bytes | None = None) -> IO[bytes]: ...
+        else:
+            def open(
+                self, mode: _ReadWriteBinaryMode = "r", pwd: bytes | None = None, *, force_zip64: bool = False
+            ) -> IO[bytes]: ...
+
+        if sys.version_info >= (3, 10):
+            def iterdir(self) -> Iterator[Self]: ...
+        else:
+            def iterdir(self) -> Iterator[Path]: ...
+
+        def is_dir(self) -> bool: ...
+        def is_file(self) -> bool: ...
+        def exists(self) -> bool: ...
+        def read_text(
+            self,
+            encoding: str | None = ...,
+            errors: str | None = ...,
+            newline: str | None = ...,
+            line_buffering: bool = ...,
+            write_through: bool = ...,
+        ) -> str: ...
+        def read_bytes(self) -> bytes: ...
+        if sys.version_info >= (3, 10):
+            def joinpath(self, *other: StrPath) -> Path: ...
+        else:
+            def joinpath(self, add: StrPath) -> Path: ...  # undocumented
+        if sys.version_info >= (3, 12):
+            def glob(self, pattern: str) -> Iterator[Self]: ...
+            def rglob(self, pattern: str) -> Iterator[Self]: ...
+            def is_symlink(self) -> Literal[False]: ...
+            def relative_to(self, other: Path, *extra: StrPath) -> str: ...
+            def match(self, path_pattern: str) -> bool: ...
+            def __eq__(self, other: object) -> bool: ...
+            def __hash__(self) -> int: ...
+
+        def __truediv__(self, add: StrPath) -> Path: ...

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

@@ -0,0 +1,32 @@
+import sys
+from _typeshed import StrOrBytesPath
+from importlib.abc import ResourceReader
+from importlib.machinery import ModuleSpec
+from types import CodeType, ModuleType
+
+__all__ = ["ZipImportError", "zipimporter"]
+
+class ZipImportError(ImportError): ...
+
+class zipimporter:
+    archive: str
+    prefix: str
+    if sys.version_info >= (3, 11):
+        def __init__(self, path: str) -> None: ...
+    else:
+        def __init__(self, path: StrOrBytesPath) -> None: ...
+
+    if sys.version_info < (3, 12):
+        def find_loader(self, fullname: str, path: str | None = None) -> tuple[zipimporter | None, list[str]]: ...  # undocumented
+        def find_module(self, fullname: str, path: str | None = None) -> zipimporter | None: ...
+
+    def get_code(self, fullname: str) -> CodeType: ...
+    def get_data(self, pathname: str) -> bytes: ...
+    def get_filename(self, fullname: str) -> str: ...
+    def get_resource_reader(self, fullname: str) -> ResourceReader | None: ...  # undocumented
+    def get_source(self, fullname: str) -> str | None: ...
+    def is_package(self, fullname: str) -> bool: ...
+    def load_module(self, fullname: str) -> ModuleType: ...
+    if sys.version_info >= (3, 10):
+        def find_spec(self, fullname: str, target: ModuleType | None = None) -> ModuleSpec | None: ...
+        def invalidate_caches(self) -> None: ...

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

@@ -0,0 +1,56 @@
+import sys
+from _typeshed import ReadableBuffer
+from typing import Literal
+
+DEFLATED: Literal[8]
+DEF_MEM_LEVEL: int  # can change
+DEF_BUF_SIZE: Literal[16384]
+MAX_WBITS: int
+ZLIB_VERSION: str  # can change
+ZLIB_RUNTIME_VERSION: str  # can change
+Z_NO_COMPRESSION: Literal[0]
+Z_PARTIAL_FLUSH: Literal[1]
+Z_BEST_COMPRESSION: Literal[9]
+Z_BEST_SPEED: Literal[1]
+Z_BLOCK: Literal[5]
+Z_DEFAULT_COMPRESSION: Literal[-1]
+Z_DEFAULT_STRATEGY: Literal[0]
+Z_FILTERED: Literal[1]
+Z_FINISH: Literal[4]
+Z_FIXED: Literal[4]
+Z_FULL_FLUSH: Literal[3]
+Z_HUFFMAN_ONLY: Literal[2]
+Z_NO_FLUSH: Literal[0]
+Z_RLE: Literal[3]
+Z_SYNC_FLUSH: Literal[2]
+Z_TREES: Literal[6]
+
+class error(Exception): ...
+
+class _Compress:
+    def compress(self, data: ReadableBuffer) -> bytes: ...
+    def flush(self, mode: int = ...) -> bytes: ...
+    def copy(self) -> _Compress: ...
+
+class _Decompress:
+    unused_data: bytes
+    unconsumed_tail: bytes
+    eof: bool
+    def decompress(self, data: ReadableBuffer, max_length: int = ...) -> bytes: ...
+    def flush(self, length: int = ...) -> bytes: ...
+    def copy(self) -> _Decompress: ...
+
+def adler32(data: ReadableBuffer, value: int = 1, /) -> int: ...
+
+if sys.version_info >= (3, 11):
+    def compress(data: ReadableBuffer, /, level: int = -1, wbits: int = 15) -> bytes: ...
+
+else:
+    def compress(data: ReadableBuffer, /, level: int = -1) -> bytes: ...
+
+def compressobj(
+    level: int = -1, method: int = 8, wbits: int = 15, memLevel: int = 8, strategy: int = 0, zdict: ReadableBuffer | None = None
+) -> _Compress: ...
+def crc32(data: ReadableBuffer, value: int = 0, /) -> int: ...
+def decompress(data: ReadableBuffer, /, wbits: int = 15, bufsize: int = 16384) -> bytes: ...
+def decompressobj(wbits: int = 15, zdict: ReadableBuffer = b"") -> _Decompress: ...

jaclang/vendor/mypy/typeshed/stdlib/zoneinfo/__init__.pyi

@@ -0,0 +1,38 @@
+from _typeshed import StrPath
+from collections.abc import Iterable, Sequence
+from datetime import datetime, timedelta, tzinfo
+from typing import Any, Protocol
+from typing_extensions import Self
+
+__all__ = ["ZoneInfo", "reset_tzpath", "available_timezones", "TZPATH", "ZoneInfoNotFoundError", "InvalidTZPathWarning"]
+
+class _IOBytes(Protocol):
+    def read(self, size: int, /) -> bytes: ...
+    def seek(self, size: int, whence: int = ..., /) -> Any: ...
+
+class ZoneInfo(tzinfo):
+    @property
+    def key(self) -> str: ...
+    def __init__(self, key: str) -> None: ...
+    @classmethod
+    def no_cache(cls, key: str) -> Self: ...
+    @classmethod
+    def from_file(cls, fobj: _IOBytes, /, key: str | None = None) -> Self: ...
+    @classmethod
+    def clear_cache(cls, *, only_keys: Iterable[str] | None = None) -> None: ...
+    def tzname(self, dt: datetime | None, /) -> str | None: ...
+    def utcoffset(self, dt: datetime | None, /) -> timedelta | None: ...
+    def dst(self, dt: datetime | None, /) -> timedelta | None: ...
+
+# Note: Both here and in clear_cache, the types allow the use of `str` where
+# a sequence of strings is required. This should be remedied if a solution
+# to this typing bug is found: https://github.com/python/typing/issues/256
+def reset_tzpath(to: Sequence[StrPath] | None = None) -> None: ...
+def available_timezones() -> set[str]: ...
+
+TZPATH: tuple[str, ...]
+
+class ZoneInfoNotFoundError(KeyError): ...
+class InvalidTZPathWarning(RuntimeWarning): ...
+
+def __dir__() -> list[str]: ...