codex-pdf 1.4.1__tar.gz → 1.4.2__tar.gz

{codex_pdf-1.4.1 → codex_pdf-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-pdf
-Version: 1.4.1
+Version: 1.4.2
 Summary: Authoritative, versioned PDF facts contract for Think Neverland tools.
 Author-email: Think Neverland <dev@thinkneverland.com>
 License-Expression: AGPL-3.0-or-later

{codex_pdf-1.4.1 → codex_pdf-1.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codex-pdf"
-version = "1.4.1"
+version = "1.4.2"
 description = "Authoritative, versioned PDF facts contract for Think Neverland tools."
 readme = "README.md"
 requires-python = ">=3.12"

{codex_pdf-1.4.1 → codex_pdf-1.4.2}/schemas/v1/codex-document.schema.json

@@ -1468,7 +1468,8 @@
           "enum": [
             "ocg_name",
             "ocg_processing_step",
-            "trap_layer"
+            "trap_layer",
+            "analysis_signal"
           ],
           "title": "Source",
           "type": "string"
@@ -1496,6 +1497,31 @@
           ],
           "default": null,
           "title": "Processing Step"
+        },
+        "confidence": {
+          "default": 0.5,
+          "maximum": 1.0,
+          "minimum": 0.0,
+          "title": "Confidence",
+          "type": "number"
+        },
+        "reason_codes": {
+          "items": {
+            "enum": [
+              "name_keyword",
+              "iso19593_processing_step",
+              "trap_layer_keyword",
+              "analysis_ocg_marked_keyword",
+              "analysis_dash_pattern",
+              "analysis_thin_stroke",
+              "analysis_stroke_dominant",
+              "analysis_dense_path_network",
+              "analysis_low_fill_ratio"
+            ],
+            "type": "string"
+          },
+          "title": "Reason Codes",
+          "type": "array"
         }
       },
       "required": [
@@ -1519,6 +1545,13 @@
           "title": "Candidates",
           "type": "array"
         },
+        "overall_confidence": {
+          "default": 0.0,
+          "maximum": 1.0,
+          "minimum": 0.0,
+          "title": "Overall Confidence",
+          "type": "number"
+        },
         "trapped_flag": {
           "anyOf": [
             {

{codex_pdf-1.4.1 → codex_pdf-1.4.2}/src/codex_pdf/extract/signals.py

@@ -18,20 +18,16 @@ def extract_analysis_signals_pikepdf(pdf_bytes: bytes) -> dict[str, Any]:
         with pikepdf.open(BytesIO(pdf_bytes)) as pdf:
             out["spot_names"] = _collect_spot_names(pdf)
             out["layer_names"] = _collect_layer_names(pdf)
-            page_signals = _extract_page_one_signals(pdf)
-            if page_signals:
-                out["page_1"] = page_signals
+            for idx, page in enumerate(pdf.pages, start=1):
+                page_signals = _extract_page_signals(page)
+                if page_signals:
+                    out[f"page_{idx}"] = page_signals
     except Exception:
         return {}
     return out
 
 
-def _extract_page_one_signals(pdf: Any) -> dict[str, Any]:
-    try:
-        page = pdf.pages[0]
-    except Exception:
-        return {}
-
+def _extract_page_signals(page: Any) -> dict[str, Any]:
     resources = page.get("/Resources") if hasattr(page, "get") else None
     cs_dict = resources.get("/ColorSpace") if resources and hasattr(resources, "get") else None
     props_dict = resources.get("/Properties") if resources and hasattr(resources, "get") else None

{codex_pdf-1.4.1 → codex_pdf-1.4.2}/src/codex_pdf/extract/summary.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import re
+from typing import Any
 
 from codex_pdf.models.v1 import (
     CodexDocument,
@@ -104,6 +105,8 @@ def _dieline_candidates(doc: CodexDocument) -> CodexSummaryDielineMetrics:
         source: str,
         ocg_id: str | None = None,
         processing_step: str | None = None,
+        confidence: float = 0.5,
+        reason_codes: list[str] | None = None,
     ) -> None:
         trimmed = name.strip()
         if not trimmed:
@@ -118,12 +121,20 @@ def _dieline_candidates(doc: CodexDocument) -> CodexSummaryDielineMetrics:
                 source=source,  # type: ignore[arg-type]
                 ocg_id=ocg_id,
                 processing_step=processing_step,
+                confidence=max(0.0, min(1.0, confidence)),
+                reason_codes=sorted(set(reason_codes or [])),  # type: ignore[arg-type]
             )
         )
 
     for ocg in doc.ocgs:
         if _DIELINE_PATTERN.search(ocg.name):
-            _add(name=ocg.name, source="ocg_name", ocg_id=ocg.ocg_id)
+            _add(
+                name=ocg.name,
+                source="ocg_name",
+                ocg_id=ocg.ocg_id,
+                confidence=0.95,
+                reason_codes=["name_keyword"],
+            )
         if ocg.iso19593_processing_step and _DIELINE_PATTERN.search(
             ocg.iso19593_processing_step
         ):
@@ -132,6 +143,8 @@ def _dieline_candidates(doc: CodexDocument) -> CodexSummaryDielineMetrics:
                 source="ocg_processing_step",
                 ocg_id=ocg.ocg_id,
                 processing_step=ocg.iso19593_processing_step,
+                confidence=0.98,
+                reason_codes=["iso19593_processing_step"],
             )
 
     for layer in doc.trap_evidence.trap_layers:
@@ -142,15 +155,165 @@ def _dieline_candidates(doc: CodexDocument) -> CodexSummaryDielineMetrics:
                 source="trap_layer",
                 ocg_id=layer.ocg_id,
                 processing_step=layer.processing_step,
+                confidence=0.9,
+                reason_codes=["trap_layer_keyword"],
+            )
+
+    for page_num, page_signal in _iter_page_signals(doc.analysis):
+        signal_hits = _dieline_signal_candidates(page_num, page_signal)
+        for hit_name, hit_confidence, hit_reasons in signal_hits:
+            _add(
+                name=hit_name,
+                source="analysis_signal",
+                confidence=hit_confidence,
+                reason_codes=hit_reasons,
             )
 
     return CodexSummaryDielineMetrics(
         count=len(candidates),
         candidates=candidates,
+        overall_confidence=max((c.confidence for c in candidates), default=0.0),
         trapped_flag=doc.trapped_flag,
     )
 
 
+def _iter_page_signals(analysis: dict[str, Any]) -> list[tuple[int, dict[str, Any]]]:
+    out: list[tuple[int, dict[str, Any]]] = []
+    for key, value in analysis.items():
+        if not isinstance(value, dict):
+            continue
+        if key.startswith("page_"):
+            suffix = key.removeprefix("page_")
+            if suffix.isdigit():
+                out.append((int(suffix), value))
+    return sorted(out, key=lambda item: item[0])
+
+
+def _as_float(value: Any) -> float | None:
+    if isinstance(value, (int, float)):
+        return float(value)
+    if isinstance(value, str):
+        try:
+            return float(value)
+        except ValueError:
+            return None
+    return None
+
+
+def _dieline_signal_candidates(
+    page_num: int,
+    page_signal: dict[str, Any],
+) -> list[tuple[str, float, list[str]]]:
+    content_ops = page_signal.get("content_ops")
+    if not isinstance(content_ops, list):
+        return []
+
+    path_ops = 0
+    stroke_ops = 0
+    fill_ops = 0
+    dash_ops = 0
+    thin_stroke_ops = 0
+    ocg_marked_content: set[str] = set()
+
+    prop_to_ocg_name = page_signal.get("prop_to_ocg_name")
+    ocg_map = prop_to_ocg_name if isinstance(prop_to_ocg_name, dict) else {}
+
+    for entry in content_ops:
+        if not isinstance(entry, dict):
+            continue
+        op = str(entry.get("op") or "").strip()
+        operands = entry.get("operands")
+        operands_list = operands if isinstance(operands, list) else []
+
+        if op in {"m", "l", "c", "v", "y", "re", "h"}:
+            path_ops += 1
+        elif op in {"S", "s"}:
+            stroke_ops += 1
+        elif op in {"f", "f*", "F", "B", "B*", "b", "b*"}:
+            fill_ops += 1
+        elif op == "d":
+            # Dashed strokes are a strong fold/crease indicator in packaging art.
+            if operands_list and isinstance(operands_list[0], list):
+                if any((_as_float(x) or 0.0) > 0.0 for x in operands_list[0]):
+                    dash_ops += 1
+        elif op == "w" and operands_list:
+            width = _as_float(operands_list[0])
+            if width is not None and width <= 1.0:
+                thin_stroke_ops += 1
+        elif op == "BDC" and len(operands_list) >= 2:
+            maybe_type = str(operands_list[0]).lstrip("/")
+            prop_name = str(operands_list[1]).lstrip("/")
+            if maybe_type == "OC":
+                mapped = ocg_map.get(prop_name)
+                if mapped and _DIELINE_PATTERN.search(str(mapped)):
+                    ocg_marked_content.add(str(mapped))
+
+    hits: list[tuple[str, float, list[str]]] = []
+    for name in sorted(ocg_marked_content):
+        hits.append(
+            (
+                f"{name} (page {page_num}, oc-marked)",
+                0.92,
+                ["analysis_ocg_marked_keyword"],
+            )
+        )
+
+    # Structural heuristics for files with missing spot/color semantics.
+    fold_like = dash_ops >= 2 and stroke_ops >= 4
+    dieline_like = (
+        stroke_ops >= 8
+        and path_ops >= 24
+        and fill_ops <= max(1, stroke_ops // 4)
+        and (thin_stroke_ops >= 2 or dash_ops >= 1)
+    )
+
+    if fold_like:
+        fold_reasons: list[str] = []
+        fold_confidence = 0.45
+        if dash_ops >= 2:
+            fold_reasons.append("analysis_dash_pattern")
+            fold_confidence += 0.2
+        if stroke_ops >= 4:
+            fold_reasons.append("analysis_stroke_dominant")
+            fold_confidence += 0.15
+        if thin_stroke_ops >= 1:
+            fold_reasons.append("analysis_thin_stroke")
+            fold_confidence += 0.1
+        hits.append(
+            (
+                f"foldline-like vector strokes (page {page_num})",
+                min(0.9, fold_confidence),
+                fold_reasons,
+            )
+        )
+    if dieline_like:
+        dieline_reasons: list[str] = []
+        dieline_confidence = 0.5
+        if path_ops >= 24:
+            dieline_reasons.append("analysis_dense_path_network")
+            dieline_confidence += 0.2
+        if stroke_ops >= 8:
+            dieline_reasons.append("analysis_stroke_dominant")
+            dieline_confidence += 0.15
+        if fill_ops <= max(1, stroke_ops // 4):
+            dieline_reasons.append("analysis_low_fill_ratio")
+            dieline_confidence += 0.1
+        if thin_stroke_ops >= 2:
+            dieline_reasons.append("analysis_thin_stroke")
+            dieline_confidence += 0.05
+        if dash_ops >= 1:
+            dieline_reasons.append("analysis_dash_pattern")
+            dieline_confidence += 0.05
+        hits.append(
+            (
+                f"dieline-like vector path network (page {page_num})",
+                min(0.95, dieline_confidence),
+                dieline_reasons,
+            )
+        )
+    return hits
+
+
 def _image_metrics(doc: CodexDocument) -> CodexSummaryImageMetrics:
     dpi_values: list[float] = []
     below_300 = 0

{codex_pdf-1.4.1 → codex_pdf-1.4.2}/src/codex_pdf/models/v1.py

@@ -328,14 +328,29 @@ class CodexSummarySpotColorMetrics(BaseModel):
 
 class CodexSummaryDielineCandidate(BaseModel):
     name: str
-    source: Literal["ocg_name", "ocg_processing_step", "trap_layer"]
+    source: Literal["ocg_name", "ocg_processing_step", "trap_layer", "analysis_signal"]
     ocg_id: str | None = None
     processing_step: str | None = None
+    confidence: float = Field(default=0.5, ge=0.0, le=1.0)
+    reason_codes: list[
+        Literal[
+            "name_keyword",
+            "iso19593_processing_step",
+            "trap_layer_keyword",
+            "analysis_ocg_marked_keyword",
+            "analysis_dash_pattern",
+            "analysis_thin_stroke",
+            "analysis_stroke_dominant",
+            "analysis_dense_path_network",
+            "analysis_low_fill_ratio",
+        ]
+    ] = Field(default_factory=list)
 
 
 class CodexSummaryDielineMetrics(BaseModel):
     count: int = 0
     candidates: list[CodexSummaryDielineCandidate] = Field(default_factory=list)
+    overall_confidence: float = Field(default=0.0, ge=0.0, le=1.0)
     trapped_flag: Literal["True", "False", "Unknown"] | None = None
 
 

{codex_pdf-1.4.1 → codex_pdf-1.4.2}/src/codex_pdf/version.py

@@ -38,5 +38,5 @@ or unreachable Redis service can never crash the codex API.
 1.3.0 (prior): SSRF hardening + /v1/walk/type4 endpoint.
 """
 
-VERSION = "1.4.0"
+VERSION = "1.4.2"
 __version__ = VERSION

codex_pdf-1.4.2/tests/test_summary_dieline.py

@@ -0,0 +1,80 @@
+from codex_pdf.extract.summary import build_document_summary
+from codex_pdf.models.v1 import CodexDocument, CodexOCG, CodexSourceRef
+
+
+def _doc_with_analysis(analysis: dict) -> CodexDocument:
+    return CodexDocument(
+        codex_version="1.4.0",
+        document_id="deadbeef",
+        source=CodexSourceRef(uri="fixture.pdf", sha256="deadbeef", size_bytes=1234),
+        analysis=analysis,
+    )
+
+
+def test_dieline_summary_detects_name_based_candidates() -> None:
+    doc = _doc_with_analysis({})
+    doc.ocgs = [CodexOCG(ocg_id="oc1", name="Dieline")]
+    summary = build_document_summary(doc)
+    assert summary.dieline.count >= 1
+    ocg_hits = [c for c in summary.dieline.candidates if c.source == "ocg_name"]
+    assert ocg_hits
+    assert all(c.confidence >= 0.9 for c in ocg_hits)
+    assert all("name_keyword" in c.reason_codes for c in ocg_hits)
+    assert summary.dieline.overall_confidence >= 0.9
+
+
+def test_dieline_summary_detects_structural_candidates_without_spot_names() -> None:
+    # No spot names / no OCG labels. Detection should still find likely linework.
+    ops = []
+    for _ in range(32):
+        ops.append({"op": "m", "operands": [0, 0]})
+        ops.append({"op": "l", "operands": [100, 0]})
+    for _ in range(12):
+        ops.append({"op": "S", "operands": []})
+    ops.extend(
+        [
+            {"op": "w", "operands": [0.5]},
+            {"op": "d", "operands": [[2, 2], 0]},
+            {"op": "d", "operands": [[3, 3], 0]},
+        ]
+    )
+    doc = _doc_with_analysis({"page_1": {"content_ops": ops}})
+    summary = build_document_summary(doc)
+    signal_hits = [c for c in summary.dieline.candidates if c.source == "analysis_signal"]
+    assert signal_hits
+    names = [c.name for c in summary.dieline.candidates]
+    assert any("dieline-like" in name for name in names)
+    assert any("foldline-like" in name for name in names)
+    fold = next(c for c in signal_hits if "foldline-like" in c.name)
+    assert fold.confidence >= 0.7
+    assert "analysis_dash_pattern" in fold.reason_codes
+    dieline = next(c for c in signal_hits if "dieline-like" in c.name)
+    assert dieline.confidence >= 0.8
+    assert "analysis_dense_path_network" in dieline.reason_codes
+    assert summary.dieline.overall_confidence >= dieline.confidence
+
+
+def test_dieline_summary_uses_non_first_page_analysis() -> None:
+    ops = []
+    for _ in range(24):
+        ops.append({"op": "re", "operands": [0, 0, 10, 10]})
+    for _ in range(10):
+        ops.append({"op": "S", "operands": []})
+    ops.extend(
+        [
+            {"op": "w", "operands": [0.75]},
+            {"op": "d", "operands": [[1, 1], 0]},
+            {"op": "d", "operands": [[1, 2], 0]},
+        ]
+    )
+    doc = _doc_with_analysis({"page_2": {"content_ops": ops}})
+    summary = build_document_summary(doc)
+    page2_hit = next(c for c in summary.dieline.candidates if "page 2" in c.name)
+    assert page2_hit.source == "analysis_signal"
+    assert page2_hit.reason_codes
+
+
+def test_dieline_summary_overall_confidence_defaults_to_zero() -> None:
+    summary = build_document_summary(_doc_with_analysis({}))
+    assert summary.dieline.count == 0
+    assert summary.dieline.overall_confidence == 0.0

{codex_pdf-1.4.1 → codex_pdf-1.4.2}/uv.lock

@@ -65,7 +65,7 @@ wheels = [
 
 [[package]]
 name = "codex-pdf"
-version = "1.4.0"
+version = "1.4.2"
 source = { editable = "." }
 dependencies = [
     { name = "fastapi" },