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 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
@@ -0,0 +1,2 @@
1
+ __title__ = "hip"
2
+ __version__ = "0.2"
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)