Upload renderer.py with huggingface_hub

renderer.py

@@ -495,14 +495,16 @@ def render_layout_to_pdf(layout: Dict[str, Any],
                          cover_bytes: Optional[bytes],
                          page_count: int = 1,
                          page_size_in: Tuple[float, float] = (PAGE_W_IN, PAGE_H_IN),
-                         output_path: Optional[Path] = None) -> bytes:
+                         output_path: Optional[Path] = None) -> Tuple[bytes, Dict[str, Any]]:
     """Render a layout JSON to a print-ready PDF.
 
     The cover is stamped on the FIRST page only (drawn as a raster
     image on top of the vector design). All subsequent pages are
     pure vector with the same layout.
 
-    Returns raw PDF bytes (and writes to ``output_path`` if given).
+    Returns ``(pdf_bytes, info)`` where ``info`` is a dict with at
+    least ``{"cover_stamped": bool}`` so the caller can surface
+    cover-stamp failures to the user.
     """
     page_w_in, page_h_in = page_size_in
 
@@ -515,6 +517,8 @@ def render_layout_to_pdf(layout: Dict[str, Any],
         buf = io.BytesIO()
     c = Canvas(buf, pagesize=(_in_to_pt(page_w_in), _in_to_pt(page_h_in)))
 
+    info: Dict[str, Any] = {"cover_stamped": False, "cover_warnings": []}
+
     for page_idx in range(page_count):
         # Start design below the safe zone
         y_pt = _in_to_pt(page_h_in - SAFE_TOP_IN)
@@ -523,13 +527,22 @@ def render_layout_to_pdf(layout: Dict[str, Any],
         c.setFillColor(HexColor(theme["bg"]))
         c.rect(0, 0, _in_to_pt(page_w_in), _in_to_pt(page_h_in), stroke=0, fill=1)
 
-        # Cover band only on page 1
-        if page_idx == 0 and cover_bytes:
-            _stamp_cover_band(c, cover_bytes, page_w_in, page_h_in)
+        # Cover band only on page 1. Always call the stamper on
+        # page 0 so a placeholder is drawn when the cover is
+        # missing/corrupt (rather than a silent blank top).
+        if page_idx == 0:
+            ok = _stamp_cover_band(c, cover_bytes or b"", page_w_in, page_h_in)
+            if page_idx == 0:
+                info["cover_stamped"] = bool(ok)
+            if not ok:
+                info["cover_warnings"].append(
+                    "Cover stamp could not be drawn — a placeholder was rendered instead."
+                )
 
         # Subtle horizontal divider between cover band and design area
         # (acts as a hairline that ties the cover to the content).
-        if page_idx == 0 and cover_bytes:
+        # Only draw if a real cover (not a placeholder) was stamped.
+        if page_idx == 0 and info["cover_stamped"]:
             c.setStrokeColor(HexColor(theme["primary"]))
             c.setLineWidth(0.5)
             divider_y_pt = _in_to_pt(page_h_in - SAFE_TOP_IN + 0.05)
@@ -574,51 +587,89 @@ def render_layout_to_pdf(layout: Dict[str, Any],
     pdf_bytes = buf.getvalue()
     if output_path is not None:
         output_path.write_bytes(pdf_bytes)
-    return pdf_bytes
+    return pdf_bytes, info
 
 
 def _stamp_cover_band(canvas: Canvas, cover_bytes: bytes,
-                      page_w_in: float, page_h_in: float) -> None:
+                      page_w_in: float, page_h_in: float) -> bool:
     """Stamp the cover image into the top ``TOP_BANNER_INCHES`` inches.
 
-    The cover is cropped to its visible *content* (not just the alpha
-    bbox, which fails on white backgrounds) and then scaled to fill
-    as much of the band as possible while preserving aspect ratio.
-    The resized raster is drawn into the PDF; everything else on
-    the page stays vector.
+    The cover is cropped to its visible *content* (alpha-based bbox)
+    and scaled to fill as much of the band as possible while
+    preserving aspect ratio. The resized raster is drawn into the
+    PDF; everything else on the page stays vector.
+
+    Returns ``True`` if a real cover image was stamped, ``False``
+    if a placeholder was drawn instead (or nothing was drawn).
+    Every early-return path logs a warning so the failure is visible
+    in the engine logs.
     """
+    band_h_in = TOP_BANNER_INCHES
+
+    def _draw_placeholder(reason: str) -> bool:
+        """Draw a thin dashed rectangle with a 'COVER' label so the
+        user can see the design intent instead of a blank top."""
+        x_in = SIDE_MARGIN_IN
+        w_in = page_w_in - 2 * SIDE_MARGIN_IN
+        h_in = band_h_in * 0.6
+        y_in = page_h_in - band_h_in + (band_h_in - h_in) / 2
+        x_pt = _in_to_pt(x_in)
+        y_pt = _in_to_pt(y_in)
+        w_pt = _in_to_pt(w_in)
+        h_pt = _in_to_pt(h_in)
+        canvas.setStrokeColor(HexColor("#9AA5A5"))
+        canvas.setLineWidth(0.6)
+        canvas.setDash(3, 3)
+        canvas.rect(x_pt, y_pt, w_pt, h_pt, stroke=1, fill=0)
+        canvas.setDash()
+        canvas.setFillColor(HexColor("#9AA5A5"))
+        canvas.setFont(DEFAULT_FONT_OBLIQUE, 10)
+        canvas.drawCentredString(
+            x_pt + w_pt / 2,
+            y_pt + h_pt / 2 - 3,
+            "[ cover unavailable — placeholder ]",
+        )
+        log.warning("[cover] placeholder drawn: %s", reason)
+        return False
+
     if not cover_bytes:
-        return
-    cover_img = Image.open(io.BytesIO(cover_bytes))
+        return _draw_placeholder("no cover bytes provided")
+
+    try:
+        cover_img = Image.open(io.BytesIO(cover_bytes))
+    except Exception as exc:
+        return _draw_placeholder(f"cannot open image: {exc}")
     if cover_img.mode != "RGBA":
         cover_img = cover_img.convert("RGBA")
 
+    src_w, src_h = cover_img.size
+    log.info("[cover] input: %dx%d px, mode=%s", src_w, src_h, cover_img.mode)
+    if src_w == 0 or src_h == 0:
+        return _draw_placeholder(f"zero-dimension image ({src_w}x{src_h})")
+
     # Content-aware crop: find the bounding box of pixels that are
     # actually drawn. Works for both transparent and white backgrounds.
     alpha = cover_img.split()[-1]
-    src_w, src_h = cover_img.size
-    # Threshold: any pixel with alpha > 32 is "solid content".
     solid = alpha.point(lambda a: 255 if a > 32 else 0)
     bbox = solid.getbbox()
-    if bbox is not None:
-        x0, y0, x1, y1 = bbox
-        # Add a small breathing margin so the subject isn't flush
-        # against the stamp edge.
-        pad = max(2, int(min(x1 - x0, y1 - y0) * 0.01))
-        x0 = max(0, x0 - pad)
-        y0 = max(0, y0 - pad)
-        x1 = min(src_w, x1 + pad)
-        y1 = min(src_h, y1 + pad)
-        cover_img = cover_img.crop((x0, y0, x1, y1))
-        log.info("[cover] alpha bbox: %dx%d -> %dx%d (orig %dx%d)",
-                 x0, y0, x1, y1, src_w, src_h)
+    if bbox is None:
+        return _draw_placeholder("no opaque content (alpha > 32) found in image")
+    x0, y0, x1, y1 = bbox
+    # Add a small breathing margin so the subject isn't flush
+    # against the stamp edge.
+    pad = max(2, int(min(x1 - x0, y1 - y0) * 0.01))
+    x0 = max(0, x0 - pad)
+    y0 = max(0, y0 - pad)
+    x1 = min(src_w, x1 + pad)
+    y1 = min(src_h, y1 + pad)
+    cover_img = cover_img.crop((x0, y0, x1, y1))
+    log.info("[cover] alpha bbox: %dx%d -> %dx%d (orig %dx%d)",
+             x0, y0, x1, y1, src_w, src_h)
 
     src_w, src_h = cover_img.size
     if src_w == 0 or src_h == 0:
-        log.warning("[cover] empty cover image; skipping stamp")
-        return
+        return _draw_placeholder(f"zero-dim after crop ({src_w}x{src_h})")
 
-    band_h_in = TOP_BANNER_INCHES
     src_aspect = src_w / src_h
 
     # Decide target size in INCHES. Use 95% of band height as the
@@ -633,6 +684,11 @@ def _stamp_cover_band(canvas: Canvas, cover_bytes: bytes,
         target_w_in = max_w_in
         target_h_in = target_w_in / src_aspect
 
+    if target_h_in < 0.1 or target_w_in < 0.1:
+        return _draw_placeholder(
+            f"computed stamp too small ({target_w_in:.2f}x{target_h_in:.2f} in)"
+        )
+
     # Resize the raster to a high pixel density (450 DPI) so the
     # embedded image stays crisp in print.
     target_h_px = max(1, int(target_h_in * 450))
@@ -661,6 +717,7 @@ def _stamp_cover_band(canvas: Canvas, cover_bytes: bytes,
         "[cover] stamped %dx%d px (%.2fx%.2f in) at (%.2f, %.2f in)",
         target_w_px, target_h_px, target_w_in, target_h_in, x_in, y_in_bottom,
     )
+    return True
 
 
 # ---------------------------------------------------------------------------