meta: python binding for HttPipe

pauloamed · pauloamed · commit eb474298f7be · 2025-02-14T14:29:11.000+01:00
diff --git a/meta/bindings/python/papermuncher.py b/meta/bindings/python/papermuncher.py
@@ -1,25 +1,17 @@
 import dataclasses as dc
-from email.message import Message
+import io
 from pathlib import Path
-from email.parser import BytesParser
 import subprocess
 import tempfile
-from typing import IO
 import magic
+import os
+import logging
 
+_logger = logging.getLogger(__name__)
 
 class Loader:
-    def handleRequest(
-        self, url: str, headers: dict[str, str]
-    ) -> tuple[int, dict[str, str], bytes]:
-        return (
-            404,
-            {
-                "mime": "text/html",
-            },
-            b"<html><body>404 Not Found</body></html>",
-        )
-
+    def handleRequest(self, url: str) -> tuple[dict[str, str], bytes]:
+        raise NotImplementedError()
 
 @dc.dataclass
 class StaticDir(Loader):
@@ -28,43 +20,141 @@ class StaticDir(Loader):
     def __init__(self, path: Path):
         self._path = path
 
-    def handleRequest(
-        self, url: str, headers: dict[str, str]
-    ) -> tuple[int, dict[str, str], bytes]:
-        path = self._path / url
+    def handleRequest(self, url: str) -> tuple[dict[str, str], bytes]:
+        # Http path starts with '/' what ends up being interpreted as the root of the FS when appending, so we rmv it
+        path = self._path / url[1:]
+
         if not path.exists():
-            return (
-                404,
-                {
-                    "mime": "text/html",
-                },
-                b"<html><body>404 Not Found</body></html>",
-            )
+            raise FileNotFoundError()
         with open(path, "rb") as f:
             return (
-                200,
                 {
                     "mime": magic.Magic(mime=True).from_file(path),
                 },
                 f.read(),
             )
 
 
+MAX_BUFFER_SIZE = 1024
+class HttpMessage():
+
+    def __init__(self):
+        self.headers = {}
+
+    def _readHeaderLines(self, reader: io.TextIOWrapper) -> list[str]:
+        lines = []
+
+        while True:
+            request_line = reader.readline().decode('utf-8')
+
+            if len(request_line) == 0:
+                raise EOFError("Input stream has ended")
+
+            if request_line == "\r\n":
+                break
+
+            lines.append(request_line)
+
+        return lines
+
+    def _addToHeader(self, header_line: str) -> None:
+        key, value = header_line.split(':')
+        self.headers[key.strip()] = value.strip()
+
+    def readHeader(self, reader: io.TextIOWrapper) -> None:
+        raise NotImplementedError()
+
+    def _readSingleChunk(self, reader: io.TextIOWrapper) -> bytes:
+        def read_chunk_content(rem_size):
+            chunk = b""
+
+            while rem_size > 0:
+                bs = min(MAX_BUFFER_SIZE, rem_size)
+                byte = reader.read(bs)
+                chunk += byte
+
+                rem_size -= bs
+            return chunk
+
+        size = int(reader.readline()[:-2])
+        chunk = read_chunk_content(size)
+
+        reader.read(2)
+
+        return chunk
+
+    def readChunkedBody(self, reader: io.TextIOWrapper) -> bytes:
+        encoded_body = b""
+        while True:
+            chunk = self._readSingleChunk(reader)
+
+            if chunk is None:
+                return None
+
+            if len(chunk) == 0:
+                break
+
+            encoded_body += chunk
+
+        return encoded_body
+
+class HttpRequest(HttpMessage):
+
+    def __init__(self, method=None, path=None, version=None):
+        super().__init__()
+        self.method = method
+        self.path = path
+        self.version = version
+
+    def readHeader(self, reader: io.TextIOWrapper) -> None:
+        header_lines = self._readHeaderLines(reader)
+        self.method, self.path, self.version = header_lines[0].split(' ')
+
+        for line in header_lines[1:]:
+            self._addToHeader(line)
+
+
+RESPONSE_MESSAGES = {
+    200: 'OK',
+    404: 'Not Found'
+}
+
+class HttpResponse(HttpMessage):
+
+    def __init__(self, code: int, headers: dict[str, str] = {}, version="1.1"):
+        super().__init__()
+        self.headers |= headers
+        self.version = version
+        self.code = code
+        self.body = None
+
+    def addHeader(self, key: str, value: str) -> None:
+        self.headers[key] = value
+
+    def addBody(self, body: bytes) -> None:
+        if not isinstance(body, bytes):
+            raise ValueError("Body must be in bytes")
+        self.body = body
+        self.addHeader("Content-Length", len(body))
+
+    def __bytes__(self) -> bytes:
+        def firstLine():
+            return f"HTTP/{self.version} {self.code} {RESPONSE_MESSAGES.get(self.code, 'No Message')}".encode()
+
+        def headers():
+            return (f"{key}: {value}".encode() for key, value in self.headers.items())
+
+        return b"\r\n".join([firstLine(), *headers(), b"", self.body or b""])
+
+
 def _run(
     args: list[str],
     loader=Loader(),
 ) -> bytes:
-    def _readRequest(fd: IO) -> Message[str, str] | None:
-        # Read the request header from the file descriptor
-        parser = BytesParser()
-        return parser.parse(fd)
-
-    def _sendResponse(fd: IO, status: int, headers: dict[str, str], body: bytes):
-        fd.write(f"HTTP/2 {status}\r\n".encode())
-        for key, value in headers.items():
-            fd.write(f"{key}: {value}\r\n".encode())
-        fd.write(b"\r\n")
-        fd.write(body)
+
+    def sendResponse(stdin: io.TextIOWrapper, response: HttpResponse):
+        stdin.write(bytes(response))
+        stdin.flush()
 
     with subprocess.Popen(
         args,
@@ -84,58 +174,63 @@ def _sendResponse(fd: IO, status: int, headers: dict[str, str], body: bytes):
         if stdin is None:
             raise ValueError("stdin is None")
 
-        while True:
-            request = _readRequest(stdout)
-            if request is None:
-                raise ValueError("request is None")
-
-            if request.preamble is None:
-                raise ValueError("request.preamble is None")
-
-            preamble = request.preamble.split(" ")
-            if preamble[0] == b"GET":
-                _sendResponse(stdin, *loader.handleRequest(preamble[1], dict(request)))
-            elif preamble[0] == b"POST":
-                payload = request.get_payload()
-                if not isinstance(payload, bytes):
-                    raise ValueError("payload is not bytes")
-                proc.terminate()
-                return payload
-            else:
-                raise ValueError("Invalid request")
-
-
-def find() -> Path:
-    return Path(__file__).parent / "bin"
-
-
-def print(
+        # The only exception we are recovering from for now is FileNotFound, which is implemented in PM's HttPipe flow
+        try:
+            while True:
+                request = HttpRequest()
+                request.readHeader(stdout)
+
+                if request.method == "GET":
+                    try:
+                        headers, asset = loader.handleRequest(request.path)
+                    except FileNotFoundError:
+                        response = HttpResponse(404)
+                    else:
+                        response = HttpResponse(200, headers)
+                        response.addBody(asset)
+
+                    sendResponse(stdin, response)
+                elif request.method == "POST":
+                    payload = request.readChunkedBody(stdout)
+                    proc.terminate()
+                    return payload
+                else:
+                    raise ValueError("Invalid request")
+        except Exception as e:
+            proc.terminate()
+            _logger.debug(stderr.read().decode('utf-8'))
+            raise e
+
+
+def printPM(
     document: bytes | str | Path,
-    mime: str = "text/html",
+    bin: str,
     loader: Loader = StaticDir(Path.cwd()),
-    bin: Path = find(),
+    *args: str,
     **kwargs: str,
 ) -> bytes:
-    extraArgs = []
+
+    extraArgs = list(args)
     for key, value in kwargs.items():
         extraArgs.append(f"--{key}")
         extraArgs.append(str(value))
 
     if isinstance(document, Path):
         return _run(
-            [str(bin), "print", "-i", str(document), "-o", "out.pdf"] + extraArgs,
+            [bin, "print", str(document)] + extraArgs,
             loader,
         )
     else:
-        with tempfile.NamedTemporaryFile(delete=False) as f:
+        with tempfile.NamedTemporaryFile(dir=loader._path) as f:
             if isinstance(document, str):
                 document = document.encode()
             f.write(document)
+            f.flush()
+
             return _run(
-                [str(bin), "print", "-i", f.name, "-o", "out.pdf"] + extraArgs,
+                [str(bin), "print", os.path.basename(f.name)] + extraArgs,
                 loader,
             )
-        return b""
 
 
-__all__ = ["Loader", "StaticDir", "print"]
+__all__ = ["Loader", "StaticDir", "printPM"]
diff --git a/meta/bindings/python/sample.py b/meta/bindings/python/sample.py
@@ -1,12 +1,52 @@
 import papermuncher
+from pathlib import Path
 
-with open("out.pdf", "wb") as f:
-    document = """
-        <p>Hello, world!</p>
-    """
-    f.write(
-        papermuncher.print(
+def sample(document, output_filename):
+    try:
+        output = papermuncher.printPM(
             document,
+            "paper-muncher",
+            papermuncher.StaticDir(Path.cwd()),
+            "--httpipe",
             paper="a4",
         )
-    )
+    except Exception as e:
+        import traceback
+        print(
+            f'Error while running paper-muncher:\n{"".join(traceback.format_tb(e.__traceback__))}\n{e}\n'
+        )
+
+    with open(output_filename, "wb") as f:
+        f.write(output)
+
+
+sample(
+    """
+    <html>
+        <head>
+            <link type="text/css" rel="stylesheet" href="./404.css"/>
+        </head>
+        <p>Hello, world!</p>
+    </html>
+    """,
+    "css_not_found.pdf"
+)
+
+sample(
+    """
+    <p>Hello, world!</p>
+    """,
+    "no_css.pdf"
+)
+
+sample(
+    """
+    <html>
+        <head>
+            <link type="text/css" rel="stylesheet" href="./test.css"/>
+        </head>
+        <p>Hello, world!</p>
+    </html>
+    """,
+    "with_css.pdf"
+)
diff --git a/meta/bindings/python/test.css b/meta/bindings/python/test.css
@@ -0,0 +1,3 @@
+p {
+    border: black solid 5px;
+}

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+p {`
	`2`	`+ border: black solid 5px;`
	`3`	`+}`