hip 0.2__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- hip/__init__.py +56 -0
- hip/__version__.py +2 -0
- hip/_body.py +73 -0
- hip/_client.py +180 -0
- hip/_connection.py +181 -0
- hip/_content.py +557 -0
- hip/_headers.py +251 -0
- hip/_network.py +252 -0
- hip/_parsers.py +531 -0
- hip/_pool.py +102 -0
- hip/_request.py +124 -0
- hip/_response.py +207 -0
- hip/_server.py +123 -0
- hip/_streams.py +199 -0
- hip/_urlencode.py +76 -0
- hip/_urlparse.py +533 -0
- hip/_urls.py +541 -0
- hip-0.2.dist-info/METADATA +111 -0
- hip-0.2.dist-info/RECORD +20 -0
- hip-0.2.dist-info/WHEEL +4 -0
hip/__init__.py
ADDED
|
@@ -0,0 +1,56 @@
|
|
|
1
|
+
from .__version__ import __title__, __version__
|
|
2
|
+
from ._client import * # Client
|
|
3
|
+
from ._connection import * # Connection, Transport
|
|
4
|
+
from ._content import * # Binary, Content, File, Files, Form, HTML, JSON, MultiPart, Text
|
|
5
|
+
from ._headers import * # Headers
|
|
6
|
+
from ._network import * # NetworkBackend, NetworkStream, timeout
|
|
7
|
+
from ._parsers import * # HTTPParser, ProtocolError
|
|
8
|
+
from ._pool import * # ConnectionPool
|
|
9
|
+
from ._request import * # Method, Request
|
|
10
|
+
from ._response import * # StatusCode, Response
|
|
11
|
+
from ._server import * # Server # serve_http, run
|
|
12
|
+
from ._streams import * # ByteStream, DuplexStream, FileStream, Stream # ByteStream, DuplexStream, FileStream, Stream
|
|
13
|
+
from ._urlencode import * # quote, unquote, urldecode, urlencode
|
|
14
|
+
from ._urls import * # QueryParams, URL
|
|
15
|
+
|
|
16
|
+
__all__ = [
|
|
17
|
+
"HTML",
|
|
18
|
+
"JSON",
|
|
19
|
+
"URL",
|
|
20
|
+
"Binary",
|
|
21
|
+
"ByteStream",
|
|
22
|
+
"Client",
|
|
23
|
+
"Connection",
|
|
24
|
+
"ConnectionPool",
|
|
25
|
+
"Content",
|
|
26
|
+
"DuplexStream",
|
|
27
|
+
"File",
|
|
28
|
+
"FileStream",
|
|
29
|
+
"Files",
|
|
30
|
+
"Form",
|
|
31
|
+
"HTTPParser",
|
|
32
|
+
"Headers",
|
|
33
|
+
"Method",
|
|
34
|
+
"MultiPart",
|
|
35
|
+
"NetworkBackend",
|
|
36
|
+
"NetworkStream",
|
|
37
|
+
"ProtocolError",
|
|
38
|
+
"QueryParams",
|
|
39
|
+
"Request",
|
|
40
|
+
"Response",
|
|
41
|
+
"Server",
|
|
42
|
+
"StatusCode",
|
|
43
|
+
"Stream",
|
|
44
|
+
"Text",
|
|
45
|
+
"Transport",
|
|
46
|
+
"__title__",
|
|
47
|
+
"__version__",
|
|
48
|
+
"open_connection",
|
|
49
|
+
"quote",
|
|
50
|
+
"run",
|
|
51
|
+
"serve_http",
|
|
52
|
+
"timeout",
|
|
53
|
+
"unquote",
|
|
54
|
+
"urldecode",
|
|
55
|
+
"urlencode",
|
|
56
|
+
]
|
hip/__version__.py
ADDED
hip/_body.py
ADDED
|
@@ -0,0 +1,73 @@
|
|
|
1
|
+
import io
|
|
2
|
+
|
|
3
|
+
from ._content import Content
|
|
4
|
+
from ._headers import Headers
|
|
5
|
+
from ._parsers import HTTPParser
|
|
6
|
+
from ._streams import Stream
|
|
7
|
+
|
|
8
|
+
__all__ = ["HTTPStream", "RequestContent", "ResponseContent"]
|
|
9
|
+
|
|
10
|
+
|
|
11
|
+
class RequestContent(Content):
|
|
12
|
+
def __init__(self, parser: HTTPParser):
|
|
13
|
+
self._parser = parser
|
|
14
|
+
|
|
15
|
+
def open(self) -> Stream:
|
|
16
|
+
return HTTPStream(self._parser, is_response=False)
|
|
17
|
+
|
|
18
|
+
|
|
19
|
+
class ResponseContent(Content):
|
|
20
|
+
def __init__(self, parser: HTTPParser):
|
|
21
|
+
self._parser = parser
|
|
22
|
+
|
|
23
|
+
def open(self) -> Stream:
|
|
24
|
+
return HTTPStream(self._parser, is_response=True)
|
|
25
|
+
|
|
26
|
+
def headers(self) -> Headers:
|
|
27
|
+
return Headers()
|
|
28
|
+
|
|
29
|
+
|
|
30
|
+
class HTTPStream(Stream):
|
|
31
|
+
def __init__(self, parser: HTTPParser, is_response: bool):
|
|
32
|
+
self._parser = parser
|
|
33
|
+
self._is_response = is_response
|
|
34
|
+
self._buffer = io.BytesIO()
|
|
35
|
+
self._finished = False
|
|
36
|
+
|
|
37
|
+
def read(self, size=-1) -> bytes:
|
|
38
|
+
if self._finished:
|
|
39
|
+
return b""
|
|
40
|
+
|
|
41
|
+
sections = []
|
|
42
|
+
length = 0
|
|
43
|
+
|
|
44
|
+
# If we have any data in the buffer read that and clear the buffer.
|
|
45
|
+
buffered = self._buffer.read()
|
|
46
|
+
if buffered:
|
|
47
|
+
sections.append(buffered)
|
|
48
|
+
length += len(buffered)
|
|
49
|
+
self._buffer.seek(0)
|
|
50
|
+
self._buffer.truncate(0)
|
|
51
|
+
|
|
52
|
+
# Read each chunk in turn.
|
|
53
|
+
while (size < 0) or (length < size):
|
|
54
|
+
section = self._parser.recv_body()
|
|
55
|
+
sections.append(section)
|
|
56
|
+
length += len(section)
|
|
57
|
+
if section == b"":
|
|
58
|
+
self._finished = True
|
|
59
|
+
break
|
|
60
|
+
|
|
61
|
+
# If we've more data than requested, then push some back into the buffer.
|
|
62
|
+
output = b"".join(sections)
|
|
63
|
+
if size > -1 and len(output) > size:
|
|
64
|
+
output, remainder = output[:size], output[size:]
|
|
65
|
+
self._buffer.write(remainder)
|
|
66
|
+
self._buffer.seek(0)
|
|
67
|
+
|
|
68
|
+
return output
|
|
69
|
+
|
|
70
|
+
def close(self) -> None:
|
|
71
|
+
self._buffer.close()
|
|
72
|
+
if self._is_response:
|
|
73
|
+
self._parser.complete()
|
hip/_client.py
ADDED
|
@@ -0,0 +1,180 @@
|
|
|
1
|
+
import types
|
|
2
|
+
import typing
|
|
3
|
+
|
|
4
|
+
from ._content import HTML, JSON, Binary, Content, Text, select_media
|
|
5
|
+
from ._headers import Headers
|
|
6
|
+
from ._pool import ConnectionPool, Transport
|
|
7
|
+
from ._request import Method, Request
|
|
8
|
+
from ._response import Response
|
|
9
|
+
from ._urls import URL
|
|
10
|
+
|
|
11
|
+
__all__ = ["Client"]
|
|
12
|
+
|
|
13
|
+
|
|
14
|
+
class Client:
|
|
15
|
+
def __init__(
|
|
16
|
+
self,
|
|
17
|
+
url: URL | str | None = None,
|
|
18
|
+
headers: Headers | typing.Mapping[str, str] | None = None,
|
|
19
|
+
):
|
|
20
|
+
if url is None:
|
|
21
|
+
url = ""
|
|
22
|
+
if headers is None:
|
|
23
|
+
headers = {"User-Agent": "dev"}
|
|
24
|
+
self.transport = ConnectionPool()
|
|
25
|
+
|
|
26
|
+
self.url = URL(url)
|
|
27
|
+
self.headers = Headers(headers)
|
|
28
|
+
self.via = RedirectMiddleware(self.transport)
|
|
29
|
+
self.media = {
|
|
30
|
+
"application/json": JSON,
|
|
31
|
+
"text/html": HTML,
|
|
32
|
+
"text/*": Text,
|
|
33
|
+
"*/*": Binary,
|
|
34
|
+
}
|
|
35
|
+
|
|
36
|
+
def build_request(
|
|
37
|
+
self,
|
|
38
|
+
method: Method | str,
|
|
39
|
+
url: URL | str,
|
|
40
|
+
headers: Headers | dict[str, str] | None = None,
|
|
41
|
+
content: Content | bytes | None = None,
|
|
42
|
+
) -> Request:
|
|
43
|
+
return Request(
|
|
44
|
+
method=method,
|
|
45
|
+
url=self.url.join(url),
|
|
46
|
+
headers=self.headers.copy_update(headers),
|
|
47
|
+
content=content,
|
|
48
|
+
)
|
|
49
|
+
|
|
50
|
+
def request(
|
|
51
|
+
self,
|
|
52
|
+
method: Method | str,
|
|
53
|
+
url: URL | str,
|
|
54
|
+
headers: Headers | dict[str, str] | None = None,
|
|
55
|
+
content: Content | bytes | None = None,
|
|
56
|
+
) -> Response:
|
|
57
|
+
request = self.build_request(method, url, headers=headers, content=content)
|
|
58
|
+
with self.via.send(request) as stream:
|
|
59
|
+
ct = stream.headers.get("Content-Type", "application/octet-stream")
|
|
60
|
+
cls = select_media(self.media, ct)
|
|
61
|
+
content = cls.parse(stream)
|
|
62
|
+
return Response(
|
|
63
|
+
status_code=stream.status_code,
|
|
64
|
+
headers=stream.headers,
|
|
65
|
+
content=content,
|
|
66
|
+
)
|
|
67
|
+
|
|
68
|
+
def stream(
|
|
69
|
+
self,
|
|
70
|
+
method: Method | str,
|
|
71
|
+
url: URL | str,
|
|
72
|
+
headers: Headers | dict[str, str] | None = None,
|
|
73
|
+
content: Content | bytes | None = None,
|
|
74
|
+
) -> Response:
|
|
75
|
+
request = self.build_request(method, url, headers=headers, content=content)
|
|
76
|
+
return self.via.send(request)
|
|
77
|
+
|
|
78
|
+
def get(
|
|
79
|
+
self,
|
|
80
|
+
url: URL | str,
|
|
81
|
+
headers: Headers | dict[str, str] | None = None,
|
|
82
|
+
):
|
|
83
|
+
return self.request("GET", url, headers=headers)
|
|
84
|
+
|
|
85
|
+
def post(
|
|
86
|
+
self,
|
|
87
|
+
url: URL | str,
|
|
88
|
+
headers: Headers | dict[str, str] | None = None,
|
|
89
|
+
content: Content | bytes | None = None,
|
|
90
|
+
):
|
|
91
|
+
return self.request("POST", url, headers=headers, content=content)
|
|
92
|
+
|
|
93
|
+
def put(
|
|
94
|
+
self,
|
|
95
|
+
url: URL | str,
|
|
96
|
+
headers: Headers | dict[str, str] | None = None,
|
|
97
|
+
content: Content | bytes | None = None,
|
|
98
|
+
):
|
|
99
|
+
return self.request("PUT", url, headers=headers, content=content)
|
|
100
|
+
|
|
101
|
+
def patch(
|
|
102
|
+
self,
|
|
103
|
+
url: URL | str,
|
|
104
|
+
headers: Headers | dict[str, str] | None = None,
|
|
105
|
+
content: Content | bytes | None = None,
|
|
106
|
+
):
|
|
107
|
+
return self.request("PATCH", url, headers=headers, content=content)
|
|
108
|
+
|
|
109
|
+
def delete(
|
|
110
|
+
self,
|
|
111
|
+
url: URL | str,
|
|
112
|
+
headers: Headers | dict[str, str] | None = None,
|
|
113
|
+
):
|
|
114
|
+
return self.request("DELETE", url, headers=headers)
|
|
115
|
+
|
|
116
|
+
def close(self):
|
|
117
|
+
self.via.close()
|
|
118
|
+
|
|
119
|
+
def __enter__(self):
|
|
120
|
+
return self
|
|
121
|
+
|
|
122
|
+
def __exit__(
|
|
123
|
+
self,
|
|
124
|
+
exc_type: type[BaseException] | None = None,
|
|
125
|
+
exc_value: BaseException | None = None,
|
|
126
|
+
traceback: types.TracebackType | None = None,
|
|
127
|
+
):
|
|
128
|
+
self.close()
|
|
129
|
+
|
|
130
|
+
def __repr__(self):
|
|
131
|
+
return f"<Client [{self.transport.description()}]>"
|
|
132
|
+
|
|
133
|
+
|
|
134
|
+
class RedirectMiddleware(Transport):
|
|
135
|
+
def __init__(self, transport: Transport) -> None:
|
|
136
|
+
self._transport = transport
|
|
137
|
+
|
|
138
|
+
def build_redirect_request(
|
|
139
|
+
self, request: Request, response: Response
|
|
140
|
+
) -> Request | None:
|
|
141
|
+
# Redirect status codes...
|
|
142
|
+
if response.status_code not in (301, 302, 303, 307, 308):
|
|
143
|
+
return None
|
|
144
|
+
|
|
145
|
+
# Redirects need a valid location header...
|
|
146
|
+
try:
|
|
147
|
+
location = URL(response.headers["Location"])
|
|
148
|
+
except (KeyError, ValueError):
|
|
149
|
+
return None
|
|
150
|
+
|
|
151
|
+
# Instantiate a redirect request...
|
|
152
|
+
method = request.method
|
|
153
|
+
url = request.url.join(location)
|
|
154
|
+
headers = request.headers
|
|
155
|
+
content = request.content
|
|
156
|
+
|
|
157
|
+
return Request(method, url, headers, content)
|
|
158
|
+
|
|
159
|
+
def send(self, request: Request) -> Response:
|
|
160
|
+
while True:
|
|
161
|
+
response = self._transport.send(request)
|
|
162
|
+
|
|
163
|
+
# Determine if we have a redirect or not.
|
|
164
|
+
redirect = self.build_redirect_request(request, response)
|
|
165
|
+
|
|
166
|
+
# If we don't have a redirect, we're done.
|
|
167
|
+
if redirect is None:
|
|
168
|
+
return response
|
|
169
|
+
|
|
170
|
+
# If we have a redirect, then we read the body of the response.
|
|
171
|
+
# Ensures that the HTTP connection is available for a new
|
|
172
|
+
# request/response cycle.
|
|
173
|
+
with response as stream:
|
|
174
|
+
stream.read()
|
|
175
|
+
|
|
176
|
+
# Make the next request
|
|
177
|
+
request = redirect
|
|
178
|
+
|
|
179
|
+
def close(self):
|
|
180
|
+
self._transport.close()
|
hip/_connection.py
ADDED
|
@@ -0,0 +1,181 @@
|
|
|
1
|
+
import types
|
|
2
|
+
import typing
|
|
3
|
+
|
|
4
|
+
if typing.TYPE_CHECKING:
|
|
5
|
+
# Once we drop 3.10 support, we can use 'typing.Self'.
|
|
6
|
+
from typing_extensions import Self
|
|
7
|
+
|
|
8
|
+
from ._body import ResponseContent
|
|
9
|
+
from ._content import Content
|
|
10
|
+
from ._headers import Headers
|
|
11
|
+
from ._network import Lock, NetworkBackend
|
|
12
|
+
from ._parsers import HTTPParser
|
|
13
|
+
from ._request import Method, Request
|
|
14
|
+
from ._response import Response
|
|
15
|
+
from ._streams import Stream
|
|
16
|
+
from ._urls import URL
|
|
17
|
+
|
|
18
|
+
__all__ = [
|
|
19
|
+
"Connection",
|
|
20
|
+
"Transport",
|
|
21
|
+
"open_connection",
|
|
22
|
+
]
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
class Transport:
|
|
26
|
+
def send(self, request: Request) -> Response:
|
|
27
|
+
raise NotImplementedError()
|
|
28
|
+
|
|
29
|
+
def close(self):
|
|
30
|
+
pass
|
|
31
|
+
|
|
32
|
+
def request(
|
|
33
|
+
self,
|
|
34
|
+
method: Method | str,
|
|
35
|
+
url: URL | str,
|
|
36
|
+
headers: Headers | dict[str, str] | None = None,
|
|
37
|
+
content: Content | bytes | None = None,
|
|
38
|
+
) -> Response:
|
|
39
|
+
request = Request(method, url, headers=headers, content=content)
|
|
40
|
+
with self.send(request) as stream:
|
|
41
|
+
body = stream.read()
|
|
42
|
+
return Response(stream.status_code, headers=stream.headers, content=body)
|
|
43
|
+
|
|
44
|
+
def stream(
|
|
45
|
+
self,
|
|
46
|
+
method: Method | str,
|
|
47
|
+
url: URL | str,
|
|
48
|
+
headers: Headers | dict[str, str] | None = None,
|
|
49
|
+
content: Content | bytes | None = None,
|
|
50
|
+
) -> Response:
|
|
51
|
+
request = Request(method, url, headers=headers, content=content)
|
|
52
|
+
return self.send(request)
|
|
53
|
+
|
|
54
|
+
|
|
55
|
+
class Connection(Transport):
|
|
56
|
+
def __init__(self, stream: Stream, origin: URL | str):
|
|
57
|
+
self._stream = stream
|
|
58
|
+
self._origin = URL(origin) if not isinstance(origin, URL) else origin
|
|
59
|
+
self._request_lock = Lock()
|
|
60
|
+
self._parser = HTTPParser(stream, mode="CLIENT")
|
|
61
|
+
|
|
62
|
+
# API for connection pool management...
|
|
63
|
+
def origin(self) -> URL:
|
|
64
|
+
return self._origin
|
|
65
|
+
|
|
66
|
+
def is_idle(self) -> bool:
|
|
67
|
+
return self._parser.is_idle()
|
|
68
|
+
|
|
69
|
+
def is_expired(self) -> bool:
|
|
70
|
+
return self._parser.is_idle() and self._parser.keepalive_expired()
|
|
71
|
+
|
|
72
|
+
def is_closed(self) -> bool:
|
|
73
|
+
return self._parser.is_closed()
|
|
74
|
+
|
|
75
|
+
def description(self) -> str:
|
|
76
|
+
return self._parser.description()
|
|
77
|
+
|
|
78
|
+
# API entry points...
|
|
79
|
+
def send(self, request: Request) -> Response:
|
|
80
|
+
# async with self._request_lock:
|
|
81
|
+
# try:
|
|
82
|
+
self._send_head(request)
|
|
83
|
+
self._send_body(request)
|
|
84
|
+
code, headers = self._recv_head()
|
|
85
|
+
content = ResponseContent(self._parser)
|
|
86
|
+
return Response(code, headers=headers, content=content)
|
|
87
|
+
|
|
88
|
+
def close(self) -> None:
|
|
89
|
+
with self._request_lock:
|
|
90
|
+
self._close()
|
|
91
|
+
|
|
92
|
+
# Top-level API for working directly with a connection.
|
|
93
|
+
def request(
|
|
94
|
+
self,
|
|
95
|
+
method: Method | str,
|
|
96
|
+
url: URL | str,
|
|
97
|
+
headers: Headers | dict[str, str] | None = None,
|
|
98
|
+
content: Content | bytes | None = None,
|
|
99
|
+
) -> Response:
|
|
100
|
+
url = self._origin.join(url)
|
|
101
|
+
request = Request(method, url, headers=headers, content=content)
|
|
102
|
+
with self.send(request) as stream:
|
|
103
|
+
body = stream.read()
|
|
104
|
+
return Response(stream.status_code, headers=stream.headers, content=body)
|
|
105
|
+
|
|
106
|
+
def stream(
|
|
107
|
+
self,
|
|
108
|
+
method: Method | str,
|
|
109
|
+
url: URL | str,
|
|
110
|
+
headers: Headers | dict[str, str] | None = None,
|
|
111
|
+
content: Content | bytes | None = None,
|
|
112
|
+
) -> Response:
|
|
113
|
+
url = self._origin.join(url)
|
|
114
|
+
request = Request(method, url, headers=headers, content=content)
|
|
115
|
+
return self.send(request)
|
|
116
|
+
|
|
117
|
+
# Send the request...
|
|
118
|
+
def _send_head(self, request: Request) -> None:
|
|
119
|
+
method = bytes(request.method)
|
|
120
|
+
target = request.url.target.encode("ascii")
|
|
121
|
+
protocol = b"HTTP/1.1"
|
|
122
|
+
self._parser.send_method_line(method, target, protocol)
|
|
123
|
+
headers = request.headers.as_byte_pairs()
|
|
124
|
+
self._parser.send_headers(headers)
|
|
125
|
+
|
|
126
|
+
def _send_body(self, request: Request) -> None:
|
|
127
|
+
with request as stream:
|
|
128
|
+
while data := stream.read(64 * 1024):
|
|
129
|
+
self._parser.send_body(data)
|
|
130
|
+
self._parser.send_body(b"")
|
|
131
|
+
|
|
132
|
+
# Receive the response...
|
|
133
|
+
def _recv_head(self) -> tuple[int, Headers]:
|
|
134
|
+
_, code, _ = self._parser.recv_status_line()
|
|
135
|
+
h = self._parser.recv_headers()
|
|
136
|
+
headers = Headers([(k.decode("ascii"), v.decode("ascii")) for k, v in h])
|
|
137
|
+
return code, headers
|
|
138
|
+
|
|
139
|
+
# Request/response cycle complete...
|
|
140
|
+
def _close(self) -> None:
|
|
141
|
+
self._parser.close()
|
|
142
|
+
|
|
143
|
+
# Builtins...
|
|
144
|
+
def __repr__(self) -> str:
|
|
145
|
+
return f"<Connection [{self._origin} {self.description()}]>"
|
|
146
|
+
|
|
147
|
+
def __enter__(self) -> "Self":
|
|
148
|
+
return self
|
|
149
|
+
|
|
150
|
+
def __exit__(
|
|
151
|
+
self,
|
|
152
|
+
exc_type: type[BaseException] | None = None,
|
|
153
|
+
exc_value: BaseException | None = None,
|
|
154
|
+
traceback: types.TracebackType | None = None,
|
|
155
|
+
):
|
|
156
|
+
self.close()
|
|
157
|
+
|
|
158
|
+
|
|
159
|
+
def open_connection(
|
|
160
|
+
url: URL | str,
|
|
161
|
+
hostname: str = "",
|
|
162
|
+
backend: NetworkBackend | None = None,
|
|
163
|
+
) -> Connection:
|
|
164
|
+
|
|
165
|
+
if isinstance(url, str):
|
|
166
|
+
url = URL(url)
|
|
167
|
+
|
|
168
|
+
if url.scheme not in ("http", "https"):
|
|
169
|
+
raise ValueError("URL scheme must be 'http://' or 'https://'.")
|
|
170
|
+
if backend is None:
|
|
171
|
+
backend = NetworkBackend()
|
|
172
|
+
|
|
173
|
+
host = url.host
|
|
174
|
+
port = url.port or {"http": 80, "https": 443}[url.scheme]
|
|
175
|
+
|
|
176
|
+
if url.scheme == "https":
|
|
177
|
+
stream = backend.connect_tls(host, port, hostname)
|
|
178
|
+
else:
|
|
179
|
+
stream = backend.connect(host, port)
|
|
180
|
+
|
|
181
|
+
return Connection(stream, url)
|