veilrender 0.3.0__tar.gz → 0.4.0__tar.gz

{veilrender-0.3.0 → veilrender-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: veilrender
-Version: 0.3.0
+Version: 0.4.0
 Summary: Headless browser rendering API — self-hostable on HF Spaces, Docker, or bare metal
 Author: Peng Ding
 License-Expression: MIT
@@ -11,8 +11,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Internet :: WWW/HTTP
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: cloakbrowser>=0.3.0
-Requires-Dist: minio>=7.2.0
+Requires-Dist: patchright>=1.0.0
 Provides-Extra: dev
 Requires-Dist: ruff==0.15.20; extra == "dev"
 Requires-Dist: ty==0.0.54; extra == "dev"

{veilrender-0.3.0 → veilrender-0.4.0}/pyproject.toml

@@ -17,8 +17,7 @@ classifiers = [
 ]
 
 dependencies = [
-    "cloakbrowser>=0.3.0",
-    "minio>=7.2.0",
+    "patchright>=1.0.0",
 ]
 
 [project.optional-dependencies]

{veilrender-0.3.0 → veilrender-0.4.0}/src/veilrender/__init__.py

@@ -1,3 +1,3 @@
 """VeilRender — headless browser rendering API."""
 
-__version__ = "0.3.0"
+__version__ = "0.4.0"

{veilrender-0.3.0 → veilrender-0.4.0}/src/veilrender/_vendor/httpserver.py

@@ -1,9 +1,9 @@
 # /// zerodep
-# version = "0.1.0"
+# version = "0.2.1"
 # deps = []
 # tier = "subsystem"
 # category = "network"
-# note = "Install/update via `zerodep add httpserver`"
+# note = "Install/update via: https://zerodep.readthedocs.io/en/latest/guide/cli/"
 # ///
 
 """Zero-dependency async HTTP server with decorator-based routing.
@@ -299,9 +299,10 @@ class JSONResponse(Response):
 class StreamingResponse:
     """HTTP response streamed from an async generator.
 
-    Writes chunks using ``Transfer-Encoding: chunked`` unless
-    ``content_type`` is ``text/event-stream`` (SSE), in which case raw
-    bytes are flushed directly for maximum compatibility with SSE clients.
+    All streaming responses use ``Transfer-Encoding: chunked`` for
+    maximum compatibility with reverse proxies and intermediaries.
+    SSE (``text/event-stream``) responses additionally set
+    ``Cache-Control: no-cache``.
 
     Args:
         generator: Async iterator yielding ``bytes`` or ``str`` chunks.
@@ -330,9 +331,8 @@ class StreamingResponse:
         is_sse = self.content_type.startswith("text/event-stream")
 
         self.headers["Content-Type"] = self.content_type
-        if not is_sse:
-            self.headers.setdefault("Transfer-Encoding", "chunked")
-        else:
+        self.headers.setdefault("Transfer-Encoding", "chunked")
+        if is_sse:
             self.headers.setdefault("Cache-Control", "no-cache")
         self.headers.setdefault("Date", _http_date())
         self.headers.setdefault("Connection", "close")
@@ -349,16 +349,12 @@ class StreamingResponse:
             async for chunk in self._generator:
                 if isinstance(chunk, str):
                     chunk = chunk.encode("utf-8")
-                if is_sse:
-                    writer.write(chunk)
-                else:
-                    writer.write(f"{len(chunk):x}\r\n".encode("latin-1"))
-                    writer.write(chunk)
-                    writer.write(b"\r\n")
-                await writer.drain()
-            if not is_sse:
-                writer.write(b"0\r\n\r\n")
+                writer.write(f"{len(chunk):x}\r\n".encode("latin-1"))
+                writer.write(chunk)
+                writer.write(b"\r\n")
                 await writer.drain()
+            writer.write(b"0\r\n\r\n")
+            await writer.drain()
         except (BrokenPipeError, ConnectionResetError, ConnectionAbortedError):
             logger.debug("Client disconnected during streaming")
         finally:
@@ -878,6 +874,22 @@ class App:
 
     # ── Connection Handling ───────────────────────────────────────────────
 
+    @staticmethod
+    async def _send_error_and_close(
+        writer: asyncio.StreamWriter,
+        response: Response | JSONResponse,
+    ) -> None:
+        """Write an error response to the client and close the connection.
+
+        Swallows broken-pipe / reset errors that occur when the client has
+        already disconnected.
+        """
+        try:
+            await response._write(writer)
+        except (BrokenPipeError, ConnectionResetError):
+            pass
+        writer.close()
+
     async def _handle_connection(
         self,
         reader: asyncio.StreamReader,
@@ -893,30 +905,43 @@ class App:
             )
         except _BadRequest as exc:
             logger.debug("Bad request from %s: %s", client_addr, exc)
-            response = Response(
-                body=str(exc),
-                status_code=400,
-                content_type="text/plain; charset=utf-8",
+            await self._send_error_and_close(
+                writer,
+                Response(
+                    body=str(exc),
+                    status_code=400,
+                    content_type="text/plain; charset=utf-8",
+                ),
             )
-            try:
-                await response._write(writer)
-            except (BrokenPipeError, ConnectionResetError):
-                pass
-            writer.close()
             return
         except HTTPException as exc:
-            response = JSONResponse({"error": exc.message}, status_code=exc.status_code)
-            try:
-                await response._write(writer)
-            except (BrokenPipeError, ConnectionResetError):
-                pass
-            writer.close()
+            await self._send_error_and_close(
+                writer,
+                JSONResponse({"error": exc.message}, status_code=exc.status_code),
+            )
             return
-        except (asyncio.TimeoutError, asyncio.IncompleteReadError):
-            writer.close()
+        except asyncio.TimeoutError:
+            logger.debug("Request read timed out from %s", client_addr)
+            await self._send_error_and_close(
+                writer,
+                JSONResponse({"error": "Request Timeout"}, status_code=408),
+            )
+            return
+        except asyncio.IncompleteReadError:
+            logger.debug("Incomplete request body from %s", client_addr)
+            await self._send_error_and_close(
+                writer,
+                JSONResponse(
+                    {"error": "Bad Request: incomplete body"}, status_code=400
+                ),
+            )
             return
         except Exception:
-            writer.close()
+            logger.debug("Failed to read request from %s", client_addr, exc_info=True)
+            await self._send_error_and_close(
+                writer,
+                JSONResponse({"error": "Internal Server Error"}, status_code=500),
+            )
             return
 
         request = Request(
@@ -951,33 +976,44 @@ class App:
         self,
         host: str = DEFAULT_HOST,
         port: int = DEFAULT_PORT,
+        *,
+        socket: str | None = None,
     ) -> None:
         """Start the server (blocking).
 
         Args:
-            host: Bind address.
-            port: Bind port. Use ``0`` for OS-assigned port.
+            host: Bind address (ignored when *socket* is set).
+            port: Bind port. Use ``0`` for OS-assigned port (ignored when
+                *socket* is set).
+            socket: Unix domain socket path. When set, the server listens
+                on a Unix socket instead of TCP. The socket file permissions
+                are restricted to owner-only (``0o600``) after creation.
+                Only available on Unix-like systems.
         """
         try:
-            asyncio.run(self._serve(host, port))
+            asyncio.run(self._serve(host, port, socket=socket))
         except KeyboardInterrupt:
             pass
 
-    async def _serve(self, host: str, port: int) -> None:
+    async def _serve(self, host: str, port: int, *, socket: str | None = None) -> None:
         """Internal async server loop."""
         self._shutdown_event = asyncio.Event()
+        self._socket_path: str | None = None
 
-        server = await asyncio.start_server(
-            self._handle_connection,
-            host,
-            port,
-        )
+        if socket:
+            server = await self._start_unix_socket(socket)
+        else:
+            server = await asyncio.start_server(
+                self._handle_connection,
+                host,
+                port,
+            )
+            addrs = server.sockets[0].getsockname() if server.sockets else (host, port)
+            self.host = addrs[0]
+            self.port = addrs[1]
+            logger.info("Serving on %s:%d", self.host, self.port)
 
         self._server = server
-        addrs = server.sockets[0].getsockname() if server.sockets else (host, port)
-        self.host = addrs[0]
-        self.port = addrs[1]
-        logger.info("Serving on %s:%d", self.host, self.port)
 
         loop = asyncio.get_running_loop()
         if sys.platform != "win32":
@@ -987,6 +1023,70 @@ class App:
         async with server:
             await self._shutdown_event.wait()
             logger.info("Shutting down server")
+            if self._socket_path:
+                self._cleanup_socket()
+
+    async def _start_unix_socket(self, socket_path: str) -> asyncio.Server:
+        """Start listening on a Unix domain socket.
+
+        Handles stale socket cleanup, permission hardening (``0o600``),
+        and registers the path for shutdown cleanup.
+
+        Args:
+            socket_path: Path for the Unix domain socket file.
+
+        Returns:
+            The ``asyncio.Server`` instance.
+
+        Raises:
+            SystemExit: If the path exists but is not a socket, or the
+                parent directory does not exist.
+        """
+        import stat as stat_mod
+
+        path = os.path.realpath(socket_path)
+
+        # Remove stale socket if present
+        if os.path.exists(path):
+            try:
+                st = os.stat(path)
+                if stat_mod.S_ISSOCK(st.st_mode):
+                    os.unlink(path)
+                    logger.info("Removed stale socket: %s", path)
+                else:
+                    logger.error("Socket path exists and is not a socket: %s", path)
+                    sys.exit(1)
+            except OSError as exc:
+                logger.error("Cannot remove stale socket %s: %s", path, exc)
+                sys.exit(1)
+
+        # Ensure parent directory exists
+        parent = os.path.dirname(path)
+        if not os.path.isdir(parent):
+            logger.error("Socket parent directory does not exist: %s", parent)
+            sys.exit(1)
+
+        server = await asyncio.start_unix_server(
+            self._handle_connection,
+            path=path,
+        )
+
+        # Restrict permissions to owner-only
+        if os.path.exists(path):
+            os.chmod(path, 0o600)
+
+        self._socket_path = path
+        logger.info("Serving on unix:%s (mode 0600)", path)
+        return server
+
+    def _cleanup_socket(self) -> None:
+        """Remove the Unix socket file on shutdown."""
+        if self._socket_path and os.path.exists(self._socket_path):
+            try:
+                os.unlink(self._socket_path)
+                logger.info("Removed socket: %s", self._socket_path)
+            except OSError:
+                pass
 
     def shutdown(self) -> None:
         """Request a graceful server shutdown.

{veilrender-0.3.0 → veilrender-0.4.0}/src/veilrender/_vendor/readability.py

@@ -1,9 +1,9 @@
 # /// zerodep
-# version = "0.1.0"
+# version = "0.2.0"
 # deps = ["soup"]
 # tier = "medium"
 # category = "text"
-# note = "Install/update via `zerodep add readability`"
+# note = "Install/update via: https://zerodep.readthedocs.io/en/latest/guide/cli/"
 # ///
 
 """HTML readability content extractor — zero-dep, stdlib only, Python 3.10+.
@@ -231,6 +231,10 @@ class ReadabilityResult:
         lang: Language code from ``<html lang="...">``, or ``None``.
         dir: Text direction (``"ltr"`` / ``"rtl"``), or ``None``.
         length: Character count of *text*.
+        score: Readability score of the best candidate container.  Higher
+            values indicate stronger confidence that the extracted content
+            is a real article rather than navigation / boilerplate.  Zero
+            when no scored candidate was found (body fallback).
     """
 
     title: str
@@ -243,6 +247,7 @@ class ReadabilityResult:
     lang: str | None = None
     dir: str | None = None
     length: int = 0
+    score: float = 0.0
 
 
 # ── Public API ───────────────────────────────────────────────────────────────
@@ -360,7 +365,7 @@ class _Readability:
         # Grab article content.  The first iteration reuses self._soup
         # (removing non-content tags in-place); retries use a faster
         # parse that skips those tags during tree construction.
-        article_html, article_text = self._grab_article()
+        article_html, article_text, article_score = self._grab_article()
 
         # If metadata title is empty, try to derive from article headings.
         title = metadata.get("title", "")
@@ -379,17 +384,19 @@ class _Readability:
             lang=lang,
             dir=direction,
             length=len(text),
+            score=article_score,
         )
 
     # ── Article grabbing (with retry) ────────────────────────────────────
 
     _PRE_CLEAN_TAGS = ["script", "style", "link", "noscript"]
 
-    def _grab_article(self) -> tuple[str, str]:
+    def _grab_article(self) -> tuple[str, str, float]:
         """Extract article content, retrying with relaxed rules if needed.
 
         Returns:
-            ``(article_html, article_text)`` tuple.
+            ``(article_html, article_text, score)`` tuple.  *score* is the
+            readability score of the best candidate (0.0 for body fallback).
         """
         ruthless = True
 
@@ -417,7 +424,7 @@ class _Readability:
                 article_text = article_tag.get_text(separator=" ", strip=True)
 
                 if len(article_text) >= RETRY_LENGTH or not ruthless:
-                    return article_html, article_text
+                    return article_html, article_text, best["score"]
 
                 # Too short — retry without ruthless filtering.
                 log.debug(
@@ -438,8 +445,8 @@ class _Readability:
         # Final fallback: return body content as-is.
         body = self._soup.find("body")
         if body is not None:
-            return body.to_html(), body.get_text(separator=" ", strip=True)
-        return "", ""
+            return body.to_html(), body.get_text(separator=" ", strip=True), 0.0
+        return "", "", 0.0
 
     # ── Pre-cleaning ─────────────────────────────────────────────────────
 
@@ -688,11 +695,17 @@ class _Readability:
 
     # ── Scoring ──────────────────────────────────────────────────────────
 
+    # Maximum ancestor levels for score propagation.  The original
+    # algorithm only propagated to parent (1x) and grandparent (0.5x).
+    # Modern SPA-rendered pages nest content 3-5 levels deep in wrapper
+    # divs, so we extend propagation with diminishing weights.
+    _ANCESTOR_WEIGHTS = [1.0, 0.5, 0.333, 0.25]
+
     def _score_paragraphs(self) -> dict[int, dict[str, Any]]:
         """Score paragraph-like nodes and propagate to ancestors.
 
         Returns:
-            Dict mapping ``id(tag)`` → ``{"tag": tag, "score": float}``.
+            Dict mapping ``id(tag)`` -> ``{"tag": tag, "score": float}``.
         """
         candidates: dict[int, dict[str, Any]] = {}
 
@@ -701,21 +714,22 @@ class _Readability:
             if len(inner_text) < MIN_PARAGRAPH_LENGTH:
                 continue
 
-            parent = tag.parent
-            grandparent = parent.parent if parent is not None else None
-
-            # Ensure parent is initialised.
-            if parent is not None and id(parent) not in candidates:
-                candidates[id(parent)] = {
-                    "tag": parent,
-                    "score": self._init_score(parent),
-                }
-            # Ensure grandparent is initialised.
-            if grandparent is not None and id(grandparent) not in candidates:
-                candidates[id(grandparent)] = {
-                    "tag": grandparent,
-                    "score": self._init_score(grandparent),
-                }
+            # Collect ancestors up to the propagation depth.
+            ancestors: list[Any] = []
+            cur = tag.parent
+            for _ in range(len(self._ANCESTOR_WEIGHTS)):
+                if cur is None or cur.name in ("html", "body", "[document]"):
+                    break
+                ancestors.append(cur)
+                cur = cur.parent
+
+            # Ensure each ancestor is initialised in the candidate map.
+            for anc in ancestors:
+                if id(anc) not in candidates:
+                    candidates[id(anc)] = {
+                        "tag": anc,
+                        "score": self._init_score(anc),
+                    }
 
             # Content score for this paragraph.
             inner_len = len(inner_text)
@@ -723,11 +737,10 @@ class _Readability:
             content_score += len(COMMAS_RE.findall(inner_text))
             content_score += min(inner_len / 100.0, 3.0)
 
-            # Propagate to parent (full) and grandparent (half).
-            if parent is not None and id(parent) in candidates:
-                candidates[id(parent)]["score"] += content_score
-            if grandparent is not None and id(grandparent) in candidates:
-                candidates[id(grandparent)]["score"] += content_score / 2.0
+            # Propagate to ancestors with diminishing weights.
+            for i, anc in enumerate(ancestors):
+                weight = self._ANCESTOR_WEIGHTS[i]
+                candidates[id(anc)]["score"] += content_score * weight
 
         # Scale scores by link density.
         for entry in candidates.values():
@@ -797,7 +810,7 @@ class _Readability:
 
         # Create an article wrapper.
         article = self._Tag("div")
-        sibling_threshold = max(10.0, best["score"] * 0.2)
+        sibling_threshold = max(10.0, best["score"] * 0.1)
 
         # If there's no parent, use the candidate itself.
         if parent is None: