1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
|
# Better codecs stubs hand-written by o11c.
# https://docs.python.org/3/library/codecs.html
from typing import (
BinaryIO,
Callable,
Iterable,
Iterator,
List,
Tuple,
Union,
)
from abc import abstractmethod
# TODO: this only satisfies the most common interface, where
# bytes is the raw form and str 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.
# Python 3.5 supposedly might change something there.
_decoded = str
_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], _encoded] # signature of Codec().encode
_decode_type = Callable[[_encoded], _decoded] # signature of Codec().decode
_stream_reader_type = Callable[[BinaryIO], 'StreamReader'] # signature of StreamReader __init__
_stream_writer_type = Callable[[BinaryIO], 'StreamWriter'] # signature of StreamWriter __init__
_incremental_encoder_type = Callable[[], 'IncrementalEncoder'] # signature of IncrementalEncoder __init__
_incremental_decode_type = 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':
...
class CodecInfo(Tuple[_encode_type, _decode_type, _stream_reader_type, _stream_writer_type]):
def __init__(self, encode: _encode_type, decode: _decode_type, streamreader: _stream_reader_type = ..., streamwriter: _stream_writer_type = ..., incrementalencoder: _incremental_encoder_type = ..., incrementaldecoder: _incremental_decode_type = ..., name: str = ...) -> None:
self.encode = encode
self.decode = decode
self.streamreader = streamreader
self.streamwriter = streamwriter
self.incrementalencoder = incrementalencoder
self.incrementaldecoder = incrementaldecoder
self.name = name
def getencoder(encoding: str) -> _encode_type:
...
def getdecoder(encoding: str) -> _encode_type:
...
def getincrementalencoder(encoding: str) -> _incremental_encoder_type:
...
def getincrementaldecoder(encoding: str) -> _incremental_encoder_type:
...
def getreader(encoding: str) -> _stream_reader_type:
...
def getwriter(encoding: str) -> _stream_writer_type:
...
def register(search_function: Callable[[str], CodecInfo]) -> None:
...
def open(filename: str, mode: str = ..., encoding: str = ..., errors: str = ..., buffering: int = ...) -> StreamReaderWriter:
...
def EncodedFile(file: BinaryIO, data_encoding: str, file_encoding: str = ..., errors: str = ...) -> 'StreamRecoder':
...
def iterencode(iterator: Iterable[_decoded], encoding: str, errors: str = ...) -> Iterator[_encoded]:
...
def iterdecode(iterator: Iterable[_encoded], encoding: str, errors: str = ...) -> Iterator[_decoded]:
...
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''
# 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]:
...
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]:
...
class IncrementalEncoder:
def __init__(self, errors: str = ...) -> None:
self.errors = errors
@abstractmethod
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:
...
class IncrementalDecoder:
def __init__(self, errors: str = ...) -> None:
self.errors = errors
@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:
...
# These are not documented but used in encodings/*.py implementations.
class BufferedIncrementalEncoder(IncrementalEncoder):
def __init__(self, errors: str = ...) -> None:
IncrementalEncoder.__init__(self, errors)
self.buffer = ''
@abstractmethod
def _buffer_encode(self, input: _decoded, errors: str, final: bool) -> _encoded:
...
def encode(self, input: _decoded, final: bool = ...) -> _encoded:
...
class BufferedIncrementalDecoder(IncrementalDecoder):
def __init__(self, errors: str = ...) -> None:
IncrementalDecoder.__init__(self, errors)
self.buffer = b''
@abstractmethod
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):
def __init__(self, stream: BinaryIO, errors: str = ...) -> None:
self.errors = errors
def write(self, obj: _decoded) -> None:
...
def writelines(self, list: List[str]) -> None:
...
def reset(self) -> None:
...
class StreamReader(Codec):
def __init__(self, stream: BinaryIO, errors: str = ...) -> None:
self.errors = errors
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:
...
class StreamReaderWriter:
def __init__(self, stream: BinaryIO, Reader: _stream_reader_type, Writer: _stream_writer_type, errors: str = ...) -> None:
...
class StreamRecoder(BinaryIO):
def __init__(self, stream: BinaryIO, encode: _encode_type, decode: _decode_type, Reader: _stream_reader_type, Writer: _stream_writer_type, errors: str = ...) -> None:
...
|
