[Refactor] http.model: better body

Author: sebastien

examples/client-gzip.py

@@ -0,0 +1,51 @@
+import asyncio
+from extra.client import HTTPClient
+from extra.http.model import HTTPBodyBlob
+
+import zlib
+
+
+class GzipDecoder:
+    def __init__(self):
+        self.decompressor = zlib.decompressobj(wbits=zlib.MAX_WBITS | 32)
+        self.buffer = io.BytesIO()
+
+    def feed(self, chunk: bytes) -> bytes | None:
+        return self.decompressor.decompress(chunk)
+
+    def flush(self) -> bytes | None:
+        return self.decompressor.flush()
+
+
+# NOTE: Start "examples/sse.py"
+async def main(path: str, host: str = "127.0.0.1", port: int = 443, ssl: bool = True):
+    transform = GzipDecoder()
+
+    with open("/dev/stdout", "wb") as f:
+        async for atom in HTTPClient.Request(
+            host=host,
+            method="GET",
+            port=port,
+            path=path,
+            timeout=11.0,
+            streaming=False,
+            headers={"Accept-Encoding": "gzip"},
+            ssl=ssl,
+        ):
+            if isinstance(atom, HTTPBodyBlob):
+                f.write(transform.feed(atom.payload) or b"")
+        f.write(transform.flush() or b"")
+
+
+if __name__ == "__main__":
+    import sys
+
+    args = sys.argv[2:] or ["/index"]
+    n = len(args)
+    asyncio.run(
+        main(
+            path="/gh/lodash/lodash/4.17.15-npm/lodash.min.js",
+            host="cdn.statically.io",
+        )
+    )
+# EOF

src/py/extra/client.py

@@ -10,12 +10,13 @@
 from .http.model import (
     HTTPRequest,
     HTTPResponse,
-    HTTPResponseStream,
-    HTTPResponseAsyncStream,
+    HTTPBodyStream,
+    HTTPBodyAsyncStream,
     HTTPBodyBlob,
-    HTTPResponseFile,
+    HTTPBodyFile,
     HTTPHeaders,
-    HTTPRequestBody,
+    HTTPBody,
+    HTTPReaderBody,
     HTTPAtom,
     HTTPProcessingStatus,
 )
@@ -348,15 +349,14 @@ async def OnRequest(
         head: dict[str, str] = request.headers
         if "Host" not in head:
             head["Host"] = host
-        body = request.body
+        body = request._body
         if not streaming and "Content-Length" not in head:
             head["Content-Length"] = (
                 "0"
                 if body is None
                 else (
                     str(body.length)
-                    if isinstance(body, HTTPBodyBlob)
-                    or isinstance(body, HTTPResponseFile)
+                    if isinstance(body, HTTPBodyBlob) or isinstance(body, HTTPBodyFile)
                     else str(body.expected or "0")
                 )
             )
@@ -371,7 +371,7 @@ async def OnRequest(
         # And send the request
         if isinstance(body, HTTPBodyBlob):
             cxn.writer.write(body.payload)
-        elif isinstance(body, HTTPResponseFile):
+        elif isinstance(body, HTTPBodyFile):
             fd: int = -1
             try:
                 fd = os.open(str(body.path), os.O_RDONLY)
@@ -384,13 +384,13 @@ async def OnRequest(
             finally:
                 if fd > 0:
                     os.close(fd)
-        elif isinstance(body, HTTPResponseStream):
+        elif isinstance(body, HTTPBodyStream):
             # No keep alive with streaming as these are long
             # lived requests.
             for chunk in body.stream:
                 cxn.writer.write(asWritable(chunk))
                 await cxn.writer.drain()
-        elif isinstance(body, HTTPResponseAsyncStream):
+        elif isinstance(body, HTTPBodyAsyncStream):
             # No keep alive with streaming as these are long
             # lived requests.
             async for chunk in body.stream:
@@ -435,13 +435,19 @@ async def OnRequest(
                     status = atom
                 elif isinstance(atom, HTTPResponse):
                     res = atom
+                    if res.body:
+                        yield res.body
                     break
                 else:
                     yield atom
             iteration += 1
         if (
+            # We continue if we have streaming
             streaming is True
             or res
+            and res.body
+            and HTTPBody.HasRemaining(res.body)
+            or res
             and res.headers.contentType in {"text/event-stream"}
         ):
             # TODO: We should swap out the body for a streaming body
@@ -475,7 +481,7 @@ async def Request(
         *,
         port: int | None = None,
         headers: dict[str, str] | None = None,
-        body: HTTPRequestBody | HTTPBodyBlob | None = None,
+        body: HTTPReaderBody | HTTPBodyBlob | None = None,
         params: dict[str, str] | str | None = None,
         ssl: bool = True,
         verified: bool = True,
@@ -587,7 +593,7 @@ async def request(
     *,
     port: int | None = None,
     headers: dict[str, str] | None = None,
-    body: HTTPRequestBody | HTTPBodyBlob | None = None,
+    body: HTTPReaderBody | HTTPBodyBlob | None = None,
     params: dict[str, str] | str | None = None,
     ssl: bool = True,
     verified: bool = True,

src/py/extra/handler.py

@@ -11,9 +11,9 @@
 from .http.model import (
     HTTPRequest,
     HTTPHeaders,
-    HTTPResponseFile,
-    HTTPResponseStream,
-    HTTPResponseAsyncStream,
+    HTTPBodyFile,
+    HTTPBodyStream,
+    HTTPBodyAsyncStream,
     HTTPBodyBlob,
     HTTPResponse,
     headername,
@@ -144,18 +144,18 @@ async def FromResponse(response: HTTPResponse) -> dict[str, Any]:
             pass
         elif isinstance(response.body, HTTPBodyBlob):
             buffer.write(response.body.payload or b"")
-        elif isinstance(response.body, HTTPResponseFile):
+        elif isinstance(response.body, HTTPBodyFile):
             with open(response.body.path, "rb") as f:
                 while data := f.read(32_000):
                     buffer.write(data)
-        elif isinstance(response.body, HTTPResponseStream):
+        elif isinstance(response.body, HTTPBodyStream):
             # TODO: Should handle exception
             try:
                 for chunk in response.body.stream:
                     buffer.write(asWritable(chunk))
             finally:
                 response.body.stream.close()
-        elif isinstance(response.body, HTTPResponseAsyncStream):
+        elif isinstance(response.body, HTTPBodyAsyncStream):
             # No keep alive with streaming as these are long
             # lived requests.
             try: