diff --git a/stdlib/2and3/codecs.pyi b/stdlib/2and3/codecs.pyi index 0ea58bc9d..8b6830adf 100644 --- a/stdlib/2and3/codecs.pyi +++ b/stdlib/2and3/codecs.pyi @@ -1,234 +1,171 @@ -# Better codecs stubs hand-written by o11c. -# https://docs.python.org/2/library/codecs.html and https://docs.python.org/3/library/codecs.html import sys -from typing import ( - Any, - BinaryIO, - Callable, - Generator, - IO, - Iterable, - List, - Optional, - Text, - TextIO, - Tuple, - Type, - TypeVar, - Union, -) +from typing import Any, BinaryIO, Callable, Generator, IO, Iterable, List, Optional, Text, TextIO, Tuple, Type, TypeVar, Union from abc import abstractmethod import types - # TODO: this only satisfies the most common interface, where # bytes (py2 str) is the raw form and str (py2 unicode) is the cooked form. # In the long run, both should become template parameters maybe? # There *are* bytes->bytes and str->str encodings in the standard library. # They are much more common in Python 2 than in Python 3. -# Python 3.5 supposedly might change something there. -_decoded = Text -_encoded = bytes +_Decoded = Text +_Encoded = bytes # TODO: It is not possible to specify these signatures correctly, because # they have an optional positional or keyword argument for errors=. -_encode_type = Callable[[_decoded], Tuple[_encoded, int]] # signature of Codec().encode -_decode_type = Callable[[_encoded], Tuple[_decoded, int]] # signature of Codec().decode -_stream_reader_type = Callable[[IO[_encoded]], 'StreamReader'] # signature of StreamReader __init__ -_stream_writer_type = Callable[[IO[_encoded]], 'StreamWriter'] # signature of StreamWriter __init__ -_incremental_encoder_type = Callable[[], 'IncrementalEncoder'] # signature of IncrementalEncoder __init__ -_incremental_decoder_type = Callable[[], 'IncrementalDecoder'] # signature of IncrementalDecoder __init__ +_Encoder = Callable[[_Decoded], Tuple[_Encoded, int]] # signature of Codec().encode +_Decoder = Callable[[_Encoded], Tuple[_Decoded, int]] # signature of Codec().decode +_StreamReader = Callable[[IO[_Encoded]], StreamReader] # signature of StreamReader __init__ +_StreamWriter = Callable[[IO[_Encoded]], StreamWriter] # signature of StreamWriter __init__ +_IncrementalEncoder = Callable[[], IncrementalEncoder] # signature of IncrementalEncoder __init__ +_IncrementalDecoder = Callable[[], IncrementalDecoder] # signature of IncrementalDecoder __init__ +def encode(obj: _Decoded, encoding: str = ..., errors: str = ...) -> _Encoded: ... +def decode(obj: _Encoded, encoding: str = ..., errors: str = ...) -> _Decoded: ... +def lookup(encoding: str) -> CodecInfo: ... - -def encode(obj: _decoded, encoding: str = ..., errors: str = ...) -> _encoded: - ... -def decode(obj: _encoded, encoding: str = ..., errors: str = ...) -> _decoded: - ... - -def lookup(encoding: str) -> 'CodecInfo': - ... -class CodecInfo(Tuple[_encode_type, _decode_type, _stream_reader_type, _stream_writer_type]): +class CodecInfo(Tuple[_Encoder, _Decoder, _StreamReader, _StreamWriter]): @property - def encode(self) -> _encode_type: ... + def encode(self) -> _Encoder: ... @property - def decode(self) -> _decode_type: ... + def decode(self) -> _Decoder: ... @property - def streamreader(self) -> _stream_reader_type: ... + def streamreader(self) -> _StreamReader: ... @property - def streamwriter(self) -> _stream_writer_type: ... + def streamwriter(self) -> _StreamWriter: ... @property - def incrementalencoder(self) -> _incremental_encoder_type: ... + def incrementalencoder(self) -> _IncrementalEncoder: ... @property - def incrementaldecoder(self) -> _incremental_decoder_type: ... + def incrementaldecoder(self) -> _IncrementalDecoder: ... name: str - def __init__(self, encode: _encode_type, decode: _decode_type, streamreader: _stream_reader_type = ..., streamwriter: _stream_writer_type = ..., incrementalencoder: _incremental_encoder_type = ..., incrementaldecoder: _incremental_decoder_type = ..., name: str = ...) -> None: ... + def __init__( + self, + encode: _Encoder, + decode: _Decoder, + streamreader: _StreamReader = ..., + streamwriter: _StreamWriter = ..., + incrementalencoder: _IncrementalEncoder = ..., + incrementaldecoder: _IncrementalDecoder = ..., + name: str = ..., + ) -> None: ... -def getencoder(encoding: str) -> _encode_type: - ... -def getdecoder(encoding: str) -> _decode_type: - ... -def getincrementalencoder(encoding: str) -> _incremental_encoder_type: - ... -def getincrementaldecoder(encoding: str) -> _incremental_decoder_type: - ... -def getreader(encoding: str) -> _stream_reader_type: - ... -def getwriter(encoding: str) -> _stream_writer_type: - ... +def getencoder(encoding: str) -> _Encoder: ... +def getdecoder(encoding: str) -> _Decoder: ... +def getincrementalencoder(encoding: str) -> _IncrementalEncoder: ... +def getincrementaldecoder(encoding: str) -> _IncrementalDecoder: ... +def getreader(encoding: str) -> _StreamReader: ... +def getwriter(encoding: str) -> _StreamWriter: ... +def register(search_function: Callable[[str], CodecInfo]) -> None: ... +def open(filename: str, mode: str = ..., encoding: str = ..., errors: str = ..., buffering: int = ...) -> StreamReaderWriter: ... +def EncodedFile(file: IO[_Encoded], data_encoding: str, file_encoding: str = ..., errors: str = ...) -> StreamRecoder: ... +def iterencode(iterator: Iterable[_Decoded], encoding: str, errors: str = ...) -> Generator[_Encoded, None, None]: ... +def iterdecode(iterator: Iterable[_Encoded], encoding: str, errors: str = ...) -> Generator[_Decoded, None, None]: ... -def register(search_function: Callable[[str], CodecInfo]) -> None: - ... - -def open(filename: str, mode: str = ..., encoding: str = ..., errors: str = ..., buffering: int = ...) -> StreamReaderWriter: - ... - -def EncodedFile(file: IO[_encoded], data_encoding: str, file_encoding: str = ..., errors: str = ...) -> 'StreamRecoder': - ... - -def iterencode(iterator: Iterable[_decoded], encoding: str, errors: str = ...) -> Generator[_encoded, None, None]: - ... -def iterdecode(iterator: Iterable[_encoded], encoding: str, errors: str = ...) -> Generator[_decoded, None, None]: - ... - -BOM = b'' -BOM_BE = b'' -BOM_LE = b'' -BOM_UTF8 = b'' -BOM_UTF16 = b'' -BOM_UTF16_BE = b'' -BOM_UTF16_LE = b'' -BOM_UTF32 = b'' -BOM_UTF32_BE = b'' -BOM_UTF32_LE = b'' +BOM: bytes +BOM_BE: bytes +BOM_LE: bytes +BOM_UTF8: bytes +BOM_UTF16: bytes +BOM_UTF16_BE: bytes +BOM_UTF16_LE: bytes +BOM_UTF32: bytes +BOM_UTF32_BE: bytes +BOM_UTF32_LE: bytes # It is expected that different actions be taken depending on which of the # three subclasses of `UnicodeError` is actually ...ed. However, the Union # is still needed for at least one of the cases. -def register_error(name: str, error_handler: Callable[[UnicodeError], Tuple[Union[str, bytes], int]]) -> None: - ... -def lookup_error(name: str) -> Callable[[UnicodeError], Tuple[Union[str, bytes], int]]: - ... - -def strict_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]: - ... -def replace_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]: - ... -def ignore_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]: - ... -def xmlcharrefreplace_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]: - ... -def backslashreplace_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]: - ... +def register_error(name: str, error_handler: Callable[[UnicodeError], Tuple[Union[str, bytes], int]]) -> None: ... +def lookup_error(name: str) -> Callable[[UnicodeError], Tuple[Union[str, bytes], int]]: ... +def strict_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]: ... +def replace_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]: ... +def ignore_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]: ... +def xmlcharrefreplace_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]: ... +def backslashreplace_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]: ... class Codec: # These are sort of @abstractmethod but sort of not. # The StreamReader and StreamWriter subclasses only implement one. - def encode(self, input: _decoded, errors: str = ...) -> Tuple[_encoded, int]: - ... - def decode(self, input: _encoded, errors: str = ...) -> Tuple[_decoded, int]: - ... + def encode(self, input: _Decoded, errors: str = ...) -> Tuple[_Encoded, int]: ... + def decode(self, input: _Encoded, errors: str = ...) -> Tuple[_Decoded, int]: ... class IncrementalEncoder: - errors = ... # type: str - def __init__(self, errors: str = ...) -> None: - ... + errors: str + def __init__(self, errors: str = ...) -> None: ... @abstractmethod - def encode(self, object: _decoded, final: bool = ...) -> _encoded: - ... - def reset(self) -> None: - ... + def encode(self, object: _Decoded, final: bool = ...) -> _Encoded: ... + def reset(self) -> None: ... # documentation says int but str is needed for the subclass. - def getstate(self) -> Union[int, _decoded]: - ... - def setstate(self, state: Union[int, _decoded]) -> None: - ... + def getstate(self) -> Union[int, _Decoded]: ... + def setstate(self, state: Union[int, _Decoded]) -> None: ... class IncrementalDecoder: - errors = ... # type: str - def __init__(self, errors: str = ...) -> None: - ... + errors: str + def __init__(self, errors: str = ...) -> None: ... @abstractmethod - def decode(self, object: _encoded, final: bool = ...) -> _decoded: - ... - def reset(self) -> None: - ... - def getstate(self) -> Tuple[_encoded, int]: - ... - def setstate(self, state: Tuple[_encoded, int]) -> None: - ... + def decode(self, object: _Encoded, final: bool = ...) -> _Decoded: ... + def reset(self) -> None: ... + def getstate(self) -> Tuple[_Encoded, int]: ... + def setstate(self, state: Tuple[_Encoded, int]) -> None: ... # These are not documented but used in encodings/*.py implementations. class BufferedIncrementalEncoder(IncrementalEncoder): - buffer = ... # type: str - def __init__(self, errors: str = ...) -> None: - ... + buffer: str + def __init__(self, errors: str = ...) -> None: ... @abstractmethod - def _buffer_encode(self, input: _decoded, errors: str, final: bool) -> _encoded: - ... - def encode(self, input: _decoded, final: bool = ...) -> _encoded: - ... + def _buffer_encode(self, input: _Decoded, errors: str, final: bool) -> _Encoded: ... + def encode(self, input: _Decoded, final: bool = ...) -> _Encoded: ... + class BufferedIncrementalDecoder(IncrementalDecoder): - buffer = ... # type: bytes - def __init__(self, errors: str = ...) -> None: - ... + buffer: bytes + def __init__(self, errors: str = ...) -> None: ... @abstractmethod - def _buffer_decode(self, input: _encoded, errors: str, final: bool) -> Tuple[_decoded, int]: - ... - def decode(self, object: _encoded, final: bool = ...) -> _decoded: - ... + def _buffer_decode(self, input: _Encoded, errors: str, final: bool) -> Tuple[_Decoded, int]: ... + def decode(self, object: _Encoded, final: bool = ...) -> _Decoded: ... # TODO: it is not possible to specify the requirement that all other # attributes and methods are passed-through from the stream. class StreamWriter(Codec): - errors = ... # type: str - def __init__(self, stream: IO[_encoded], errors: str = ...) -> None: - ... - def write(self, obj: _decoded) -> None: - ... - def writelines(self, list: Iterable[_decoded]) -> None: - ... - def reset(self) -> None: - ... + errors: str + def __init__(self, stream: IO[_Encoded], errors: str = ...) -> None: ... + def write(self, obj: _Decoded) -> None: ... + def writelines(self, list: Iterable[_Decoded]) -> None: ... + def reset(self) -> None: ... class StreamReader(Codec): - errors = ... # type: str - def __init__(self, stream: IO[_encoded], errors: str = ...) -> None: - ... - def read(self, size: int = ..., chars: int = ..., firstline: bool = ...) -> _decoded: - ... - def readline(self, size: int = ..., keepends: bool = ...) -> _decoded: - ... - def readlines(self, sizehint: int = ..., keepends: bool = ...) -> List[_decoded]: - ... - def reset(self) -> None: - ... + errors: str + def __init__(self, stream: IO[_Encoded], errors: str = ...) -> None: ... + def read(self, size: int = ..., chars: int = ..., firstline: bool = ...) -> _Decoded: ... + def readline(self, size: int = ..., keepends: bool = ...) -> _Decoded: ... + def readlines(self, sizehint: int = ..., keepends: bool = ...) -> List[_Decoded]: ... + def reset(self) -> None: ... -_T = TypeVar('_T', bound='StreamReaderWriter') +_T = TypeVar("_T", bound=StreamReaderWriter) # Doesn't actually inherit from TextIO, but wraps a BinaryIO to provide text reading and writing # and delegates attributes to the underlying binary stream with __getattr__. class StreamReaderWriter(TextIO): - def __init__(self, stream: IO[_encoded], Reader: _stream_reader_type, Writer: _stream_writer_type, errors: str = ...) -> None: ... - def read(self, size: int= ...) -> _decoded: ... - def readline(self, size: Optional[int] = ...) -> _decoded: ... - def readlines(self, sizehint: Optional[int] = ...) -> List[_decoded]: ... + def __init__(self, stream: IO[_Encoded], Reader: _StreamReader, Writer: _StreamWriter, errors: str = ...) -> None: ... + def read(self, size: int = ...) -> _Decoded: ... + def readline(self, size: Optional[int] = ...) -> _Decoded: ... + def readlines(self, sizehint: Optional[int] = ...) -> List[_Decoded]: ... if sys.version_info >= (3,): def __next__(self) -> Text: ... else: def next(self) -> Text: ... def __iter__(self: _T) -> _T: ... # This actually returns None, but that's incompatible with the supertype - def write(self, data: _decoded) -> int: ... - def writelines(self, list: Iterable[_decoded]) -> None: ... + def write(self, data: _Decoded) -> int: ... + def writelines(self, list: Iterable[_Decoded]) -> None: ... def reset(self) -> None: ... # Same as write() def seek(self, offset: int, whence: int = ...) -> int: ... def __enter__(self: _T) -> _T: ... - def __exit__(self, typ: Optional[Type[BaseException]], exc: Optional[BaseException], tb: Optional[types.TracebackType]) -> bool: ... + def __exit__( + self, typ: Optional[Type[BaseException]], exc: Optional[BaseException], tb: Optional[types.TracebackType] + ) -> bool: ... def __getattr__(self, name: str) -> Any: ... - # These methods don't actually exist directly, but they are needed to satisfy the TextIO # interface. At runtime, they are delegated through __getattr__. def close(self) -> None: ... @@ -241,11 +178,18 @@ class StreamReaderWriter(TextIO): def tell(self) -> int: ... def writable(self) -> bool: ... -_SRT = TypeVar('_SRT', bound=StreamRecoder) +_SRT = TypeVar("_SRT", bound=StreamRecoder) class StreamRecoder(BinaryIO): - def __init__(self, stream: IO[_encoded], encode: _encode_type, decode: _decode_type, Reader: _stream_reader_type, Writer: _stream_writer_type, errors: str = ...) -> None: - ... + def __init__( + self, + stream: IO[_Encoded], + encode: _Encoder, + decode: _Decoder, + Reader: _StreamReader, + Writer: _StreamWriter, + errors: str = ..., + ) -> None: ... def read(self, size: int = ...) -> bytes: ... def readline(self, size: Optional[int] = ...) -> bytes: ... def readlines(self, sizehint: Optional[int] = ...) -> List[bytes]: ... @@ -259,8 +203,9 @@ class StreamRecoder(BinaryIO): def reset(self) -> None: ... def __getattr__(self, name: str) -> Any: ... def __enter__(self: _SRT) -> _SRT: ... - def __exit__(self, type: Optional[Type[BaseException]], value: Optional[BaseException], tb: Optional[types.TracebackType]) -> bool: ... - + def __exit__( + self, type: Optional[Type[BaseException]], value: Optional[BaseException], tb: Optional[types.TracebackType] + ) -> bool: ... # These methods don't actually exist directly, but they are needed to satisfy the BinaryIO # interface. At runtime, they are delegated through __getattr__. def seek(self, offset: int, whence: int = ...) -> int: ... diff --git a/stdlib/3/io.pyi b/stdlib/3/io.pyi index f43e76d7d..b306b8ddd 100644 --- a/stdlib/3/io.pyi +++ b/stdlib/3/io.pyi @@ -263,4 +263,4 @@ class StringIO(TextIOWrapper): def __enter__(self) -> 'StringIO': ... class IncrementalNewlineDecoder(codecs.IncrementalDecoder): - def decode(self, input: codecs._encoded, final: bool = ...) -> codecs._decoded: ... + def decode(self, input: bytes, final: bool = ...) -> str: ...