mirror of
https://github.com/davidhalter/typeshed.git
synced 2025-12-08 13:04:46 +08:00
be0ef21167
This protocol is only used for our Python 3.8 stubs. Therefore it's best to limit its availability as much as possible.
289 lines
9.2 KiB
Python
289 lines
9.2 KiB
Python
import io
|
|
import sys
|
|
from _typeshed import StrOrBytesPath, StrPath, _BufferWithLen
|
|
from collections.abc import Callable, Iterable, Iterator
|
|
from os import PathLike
|
|
from types import TracebackType
|
|
from typing import IO, Any, Protocol, overload
|
|
from typing_extensions import Literal, Self, TypeAlias
|
|
|
|
__all__ = [
|
|
"BadZipFile",
|
|
"BadZipfile",
|
|
"error",
|
|
"ZIP_STORED",
|
|
"ZIP_DEFLATED",
|
|
"ZIP_BZIP2",
|
|
"ZIP_LZMA",
|
|
"is_zipfile",
|
|
"ZipInfo",
|
|
"ZipFile",
|
|
"PyZipFile",
|
|
"LargeZipFile",
|
|
]
|
|
|
|
if sys.version_info >= (3, 8):
|
|
__all__ += ["Path"]
|
|
|
|
_DateTuple: TypeAlias = tuple[int, int, int, int, int, int]
|
|
_ReadWriteMode: TypeAlias = Literal["r", "w"]
|
|
_ReadWriteBinaryMode: TypeAlias = Literal["r", "w", "rb", "wb"]
|
|
_ZipFileMode: TypeAlias = Literal["r", "w", "x", "a"]
|
|
|
|
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: ...
|
|
elif sys.version_info >= (3, 8):
|
|
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: ...
|
|
else:
|
|
def __init__(
|
|
self,
|
|
file: StrPath | IO[bytes],
|
|
mode: _ZipFileMode = "r",
|
|
compression: int = 0,
|
|
allowZip64: bool = True,
|
|
compresslevel: int | None = None,
|
|
) -> 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: _BufferWithLen | 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: ...
|
|
|
|
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: ...
|
|
if sys.version_info >= (3, 8):
|
|
@classmethod
|
|
def from_file(cls, filename: StrPath, arcname: StrPath | None = None, *, strict_timestamps: bool = True) -> Self: ...
|
|
else:
|
|
@classmethod
|
|
def from_file(cls, filename: StrPath, arcname: StrPath | None = None) -> Self: ...
|
|
|
|
def is_dir(self) -> bool: ...
|
|
def FileHeader(self, zip64: bool | None = None) -> bytes: ...
|
|
|
|
if sys.version_info >= (3, 8):
|
|
if sys.version_info < (3, 9):
|
|
class _PathOpenProtocol(Protocol):
|
|
def __call__(self, mode: _ReadWriteMode = "r", pwd: bytes | None = ..., *, force_zip64: bool = ...) -> IO[bytes]: ...
|
|
|
|
class Path:
|
|
@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: ...
|
|
|
|
def __init__(self, root: ZipFile | StrPath | IO[bytes], at: str = "") -> None: ...
|
|
if sys.version_info >= (3, 9):
|
|
def open(
|
|
self,
|
|
mode: _ReadWriteBinaryMode = "r",
|
|
encoding: str | None = None,
|
|
*args: Any,
|
|
pwd: bytes | None = None,
|
|
**kwargs: Any,
|
|
) -> IO[bytes]: ...
|
|
else:
|
|
@property
|
|
def open(self) -> _PathOpenProtocol: ...
|
|
|
|
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
|
|
|
|
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
|