-
-
Notifications
You must be signed in to change notification settings - Fork 2k
Expand file tree
/
Copy pathclient.pyi
More file actions
318 lines (289 loc) · 10.4 KB
/
Copy pathclient.pyi
File metadata and controls
318 lines (289 loc) · 10.4 KB
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
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
import email.message
import io
import ssl
import sys
import types
from _typeshed import MaybeNone, ReadableBuffer, StrOrBytesPath, SupportsRead, SupportsReadline, WriteableBuffer
from collections.abc import Callable, Iterable, Iterator, Mapping
from email._policybase import _MessageT
from socket import socket
from typing import BinaryIO, Final, TypeAlias, TypeVar, overload
from typing_extensions import Self, deprecated
__all__ = [
"HTTPResponse",
"HTTPConnection",
"HTTPException",
"NotConnected",
"UnknownProtocol",
"UnknownTransferEncoding",
"UnimplementedFileMode",
"IncompleteRead",
"InvalidURL",
"ImproperConnectionState",
"CannotSendRequest",
"CannotSendHeader",
"ResponseNotReady",
"BadStatusLine",
"LineTooLong",
"RemoteDisconnected",
"error",
"responses",
"HTTPSConnection",
]
_DataType: TypeAlias = SupportsRead[bytes] | Iterable[ReadableBuffer] | ReadableBuffer
_T = TypeVar("_T")
_HeaderValue: TypeAlias = ReadableBuffer | str | int
HTTP_PORT: Final = 80
HTTPS_PORT: Final = 443
# Keep these global constants in sync with http.HTTPStatus (http/__init__.pyi).
# They are present for backward compatibility reasons.
CONTINUE: Final = 100
SWITCHING_PROTOCOLS: Final = 101
PROCESSING: Final = 102
EARLY_HINTS: Final = 103
OK: Final = 200
CREATED: Final = 201
ACCEPTED: Final = 202
NON_AUTHORITATIVE_INFORMATION: Final = 203
NO_CONTENT: Final = 204
RESET_CONTENT: Final = 205
PARTIAL_CONTENT: Final = 206
MULTI_STATUS: Final = 207
ALREADY_REPORTED: Final = 208
IM_USED: Final = 226
MULTIPLE_CHOICES: Final = 300
MOVED_PERMANENTLY: Final = 301
FOUND: Final = 302
SEE_OTHER: Final = 303
NOT_MODIFIED: Final = 304
USE_PROXY: Final = 305
TEMPORARY_REDIRECT: Final = 307
PERMANENT_REDIRECT: Final = 308
BAD_REQUEST: Final = 400
UNAUTHORIZED: Final = 401
PAYMENT_REQUIRED: Final = 402
FORBIDDEN: Final = 403
NOT_FOUND: Final = 404
METHOD_NOT_ALLOWED: Final = 405
NOT_ACCEPTABLE: Final = 406
PROXY_AUTHENTICATION_REQUIRED: Final = 407
REQUEST_TIMEOUT: Final = 408
CONFLICT: Final = 409
GONE: Final = 410
LENGTH_REQUIRED: Final = 411
PRECONDITION_FAILED: Final = 412
if sys.version_info >= (3, 13):
CONTENT_TOO_LARGE: Final = 413
REQUEST_ENTITY_TOO_LARGE: Final = 413
if sys.version_info >= (3, 13):
URI_TOO_LONG: Final = 414
REQUEST_URI_TOO_LONG: Final = 414
UNSUPPORTED_MEDIA_TYPE: Final = 415
if sys.version_info >= (3, 13):
RANGE_NOT_SATISFIABLE: Final = 416
REQUESTED_RANGE_NOT_SATISFIABLE: Final = 416
EXPECTATION_FAILED: Final = 417
IM_A_TEAPOT: Final = 418
MISDIRECTED_REQUEST: Final = 421
if sys.version_info >= (3, 13):
UNPROCESSABLE_CONTENT: Final = 422
UNPROCESSABLE_ENTITY: Final = 422
LOCKED: Final = 423
FAILED_DEPENDENCY: Final = 424
TOO_EARLY: Final = 425
UPGRADE_REQUIRED: Final = 426
PRECONDITION_REQUIRED: Final = 428
TOO_MANY_REQUESTS: Final = 429
REQUEST_HEADER_FIELDS_TOO_LARGE: Final = 431
UNAVAILABLE_FOR_LEGAL_REASONS: Final = 451
INTERNAL_SERVER_ERROR: Final = 500
NOT_IMPLEMENTED: Final = 501
BAD_GATEWAY: Final = 502
SERVICE_UNAVAILABLE: Final = 503
GATEWAY_TIMEOUT: Final = 504
HTTP_VERSION_NOT_SUPPORTED: Final = 505
VARIANT_ALSO_NEGOTIATES: Final = 506
INSUFFICIENT_STORAGE: Final = 507
LOOP_DETECTED: Final = 508
NOT_EXTENDED: Final = 510
NETWORK_AUTHENTICATION_REQUIRED: Final = 511
responses: dict[int, str]
class HTTPMessage(email.message.Message[str, str]):
def getallmatchingheaders(self, name: str) -> list[str]: ... # undocumented
@overload
def parse_headers(fp: SupportsReadline[bytes], _class: Callable[[], _MessageT]) -> _MessageT: ...
@overload
def parse_headers(fp: SupportsReadline[bytes]) -> HTTPMessage: ...
class HTTPResponse(io.BufferedIOBase, BinaryIO): # type: ignore[misc] # incompatible method definitions in the base classes
msg: HTTPMessage
headers: HTTPMessage
version: int
debuglevel: int
fp: io.BufferedReader
closed: bool
status: int
reason: str
chunked: bool
chunk_left: int | None
length: int | None
will_close: bool
# url is set on instances of the class in urllib.request.AbstractHTTPHandler.do_open
# to match urllib.response.addinfourl's interface.
# It's not set in HTTPResponse.__init__ or any other method on the class
url: str
def __init__(self, sock: socket, debuglevel: int = 0, method: str | None = None, url: str | None = None) -> None: ...
def peek(self, n: int = -1) -> bytes: ...
def read(self, amt: int | None = None) -> bytes: ...
def read1(self, n: int = -1) -> bytes: ...
def readinto(self, b: WriteableBuffer) -> int: ...
def readline(self, limit: int = -1) -> bytes: ... # type: ignore[override]
@overload
def getheader(self, name: str) -> str | None: ...
@overload
def getheader(self, name: str, default: _T) -> str | _T: ...
def getheaders(self) -> list[tuple[str, str]]: ...
def isclosed(self) -> bool: ...
def __iter__(self) -> Iterator[bytes]: ...
def __enter__(self) -> Self: ...
def __exit__(
self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
) -> None: ...
@deprecated("Deprecated since Python 3.9. Use `HTTPResponse.headers` attribute instead.")
def info(self) -> HTTPMessage: ...
@deprecated("Deprecated since Python 3.9. Use `HTTPResponse.url` attribute instead.")
def geturl(self) -> str: ...
@deprecated("Deprecated since Python 3.9. Use `HTTPResponse.status` attribute instead.")
def getcode(self) -> int: ...
def begin(self) -> None: ...
class HTTPConnection:
blocksize: int
auto_open: int # undocumented
debuglevel: int
default_port: int # undocumented
response_class: type[HTTPResponse] # undocumented
timeout: float | None
host: str
port: int
sock: socket | MaybeNone # can be `None` if `.connect()` was not called
if sys.version_info >= (3, 15):
def __init__(
self,
host: str,
port: int | None = None,
timeout: float | None = ...,
source_address: tuple[str, int] | None = None,
blocksize: int = 8192,
*,
max_response_headers: int | None = None,
) -> None: ...
else:
def __init__(
self,
host: str,
port: int | None = None,
timeout: float | None = ...,
source_address: tuple[str, int] | None = None,
blocksize: int = 8192,
) -> None: ...
def request(
self,
method: str,
url: str,
body: _DataType | str | None = None,
headers: Mapping[str, _HeaderValue] = {},
*,
encode_chunked: bool = False,
) -> None: ...
def getresponse(self) -> HTTPResponse: ...
def set_debuglevel(self, level: int) -> None: ...
if sys.version_info >= (3, 12):
def get_proxy_response_headers(self) -> HTTPMessage | None: ...
def set_tunnel(self, host: str, port: int | None = None, headers: Mapping[str, str] | None = None) -> None: ...
def connect(self) -> None: ...
def close(self) -> None: ...
def putrequest(self, method: str, url: str, skip_host: bool = False, skip_accept_encoding: bool = False) -> None: ...
def putheader(self, header: str | bytes, *values: _HeaderValue) -> None: ...
def endheaders(self, message_body: _DataType | None = None, *, encode_chunked: bool = False) -> None: ...
def send(self, data: _DataType | str) -> None: ...
class HTTPSConnection(HTTPConnection):
# Can be `None` if `.connect()` was not called:
sock: ssl.SSLSocket | MaybeNone
if sys.version_info >= (3, 15):
def __init__(
self,
host: str,
port: int | None = None,
*,
timeout: float | None = ...,
source_address: tuple[str, int] | None = None,
context: ssl.SSLContext | None = None,
blocksize: int = 8192,
max_response_headers: int | None = None,
) -> None: ...
elif sys.version_info >= (3, 12):
def __init__(
self,
host: str,
port: int | None = None,
*,
timeout: float | None = ...,
source_address: tuple[str, int] | None = None,
context: ssl.SSLContext | None = None,
blocksize: int = 8192,
) -> None: ...
else:
@overload
def __init__(
self,
host: str,
port: int | None = None,
key_file: None = None,
cert_file: None = None,
timeout: float | None = ...,
source_address: tuple[str, int] | None = None,
*,
context: ssl.SSLContext | None = None,
check_hostname: None = None,
blocksize: int = 8192,
) -> None: ...
@overload
@deprecated(
"The `key_file`, `cert_file`, `check_hostname` parameters are deprecated since Python 3.6; "
"removed in Python 3.12. Use `context` parameter instead."
)
def __init__(
self,
host: str,
port: int | None = None,
key_file: StrOrBytesPath | None = None,
cert_file: StrOrBytesPath | None = None,
timeout: float | None = ...,
source_address: tuple[str, int] | None = None,
*,
context: ssl.SSLContext | None = None,
check_hostname: bool | None = None,
blocksize: int = 8192,
) -> None: ...
key_file: StrOrBytesPath | None
cert_file: StrOrBytesPath | None
class HTTPException(Exception): ...
error = HTTPException
class NotConnected(HTTPException): ...
class InvalidURL(HTTPException): ...
class UnknownProtocol(HTTPException):
def __init__(self, version: str) -> None: ...
class UnknownTransferEncoding(HTTPException): ...
class UnimplementedFileMode(HTTPException): ...
class IncompleteRead(HTTPException):
def __init__(self, partial: bytes, expected: int | None = None) -> None: ...
partial: bytes
expected: int | None
class ImproperConnectionState(HTTPException): ...
class CannotSendRequest(ImproperConnectionState): ...
class CannotSendHeader(ImproperConnectionState): ...
class ResponseNotReady(ImproperConnectionState): ...
class BadStatusLine(HTTPException):
def __init__(self, line: str) -> None: ...
class LineTooLong(HTTPException):
def __init__(self, line_type: str) -> None: ...
class RemoteDisconnected(ConnectionResetError, BadStatusLine): ...