sigdetect 0.5.2__py3-none-any.whl → 0.5.3__py3-none-any.whl

sigdetect/detector/pymupdf_engine.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from pathlib import Path
+import re
 from typing import Iterable, cast
 
 from .pypdf2_engine import PyPDF2Detector
@@ -26,6 +27,23 @@ class PyMuPDFDetector(PyPDF2Detector):
         "representative": ("representative", "guardian", "parent"),
         "attorney": ("attorney", "counsel", "lawyer"),
     }
+    RETAINER_CLIENT_PATTERNS = (
+        re.compile(r"\bclient\b", re.IGNORECASE),
+        re.compile(r"\bpatient\b", re.IGNORECASE),
+        re.compile(r"\bagreed\b", re.IGNORECASE),
+        re.compile(r"\baccepted\b", re.IGNORECASE),
+        re.compile(r"\bby:\b", re.IGNORECASE),
+        re.compile(r"\bon this date\b", re.IGNORECASE),
+        re.compile(r"\bname\b", re.IGNORECASE),
+    )
+    RETAINER_FIRM_PATTERNS = (
+        re.compile(r"\battorney\b", re.IGNORECASE),
+        re.compile(r"\bauthorized\b", re.IGNORECASE),
+        re.compile(r"\brepresentative\b", re.IGNORECASE),
+        re.compile(r"\bfirm\b", re.IGNORECASE),
+        re.compile(r"\bcounsel\b", re.IGNORECASE),
+        re.compile(r"\blaw\b", re.IGNORECASE),
+    )
 
     def __init__(self, configuration):
         if fitz is None:  # pragma: no cover - optional dependency
@@ -47,6 +65,7 @@ class PyMuPDFDetector(PyPDF2Detector):
             widget_map = self._CollectWidgetRects(document)
             self._ApplyWidgetRects(result.Signatures, widget_map)
             self._InferPseudoRects(result.Signatures, document)
+            self._ExpandRetainerImageSignatures(result, document)
         return result
 
     # ───────────────────────────────── widget helpers ─────────────────────────────────
@@ -116,6 +135,233 @@ class PyMuPDFDetector(PyPDF2Detector):
                         signature.Page = page_index + 1
                     break
 
+    # ───────────────────────── retainer image expansion ─────────────────────────
+    def _ExpandRetainerImageSignatures(self, result, document) -> None:
+        if self.Profile != "retainer":
+            return
+        if not self.Configuration.PseudoSignatures:
+            return
+        if not result.Signatures:
+            return
+
+        signatures_by_page: dict[int, list[Signature]] = {}
+        for sig in result.Signatures:
+            if sig.Page:
+                signatures_by_page.setdefault(sig.Page, []).append(sig)
+
+        added = False
+        image_pages: set[int] = set()
+        for page_index in range(document.page_count):
+            page_number = page_index + 1
+            page = document.load_page(page_index)
+            image_rects = self._FilterSignatureImageRects(self._CollectImageRects(page), page.rect)
+            if not image_rects:
+                continue
+
+            lines = self._ExtractLines(page)
+            if not self._HasRetainerSignatureCue(lines):
+                continue
+            image_pages.add(page_number)
+            anchors = self._CollectRetainerRoleAnchors(lines)
+            roles_for_rects = self._AssignRolesToImages(
+                image_rects,
+                anchors,
+                signatures_by_page.get(page_number, []),
+            )
+
+            existing_on_page = signatures_by_page.get(page_number, [])
+            existing_rects: list[tuple[Signature, fitz.Rect]] = []
+            for sig in existing_on_page:
+                if sig.BoundingBox:
+                    existing_rects.append(
+                        (sig, self._PdfTupleToRect(sig.BoundingBox, page.rect.height))
+                    )
+
+            for rect, role in zip(image_rects, roles_for_rects):
+                matched_sig = None
+                best_overlap = 0.0
+                for sig, sig_rect in existing_rects:
+                    overlap = self._OverlapRatio(rect, sig_rect)
+                    if overlap > best_overlap:
+                        best_overlap = overlap
+                        matched_sig = sig
+                if matched_sig and best_overlap >= 0.6:
+                    matched_sig.BoundingBox = self._RectToPdfTuple(rect, page.rect.height)
+                    if not matched_sig.RenderType:
+                        matched_sig.RenderType = "drawn"
+                    if (
+                        role != "unknown"
+                        and (
+                            matched_sig.Role == "unknown"
+                            or matched_sig.FieldName == "vendor_or_acro_detected"
+                            or matched_sig.Hint == "VendorOrAcroOnly"
+                        )
+                    ):
+                        matched_sig.Role = role
+                        matched_sig.Score = max(int(matched_sig.Score or 0), 1)
+                        matched_sig.Scores = {role: matched_sig.Score}
+                        matched_sig.Evidence = (matched_sig.Evidence or []) + ["image:retainer"]
+                    continue
+
+                if role == "unknown":
+                    role = "firm"
+                new_sig = Signature(
+                    Page=page_number,
+                    FieldName="vendor_or_acro_detected",
+                    Role=role,
+                    Score=1,
+                    Scores={role: 1},
+                    Evidence=["image:retainer", "pseudo:true"],
+                    Hint="VendorOrAcroOnly",
+                    RenderType="drawn",
+                    BoundingBox=self._RectToPdfTuple(rect, page.rect.height),
+                )
+                result.Signatures.append(new_sig)
+                signatures_by_page.setdefault(page_number, []).append(new_sig)
+                added = True
+
+        if added:
+            if image_pages:
+                filtered: list[Signature] = []
+                for sig in result.Signatures:
+                    if sig.Page and sig.Page not in image_pages:
+                        if sig.FieldName == "vendor_or_acro_detected" or not self._HasBBox(sig.BoundingBox):
+                            continue
+                    filtered.append(sig)
+                result.Signatures = filtered
+            pages = sorted({sig.Page for sig in result.Signatures if sig.Page})
+            result.SignatureCount = len(result.Signatures)
+            result.SignaturePages = ",".join(str(p) for p in pages)
+            roles = sorted({sig.Role for sig in result.Signatures if sig.Role and sig.Role != "unknown"})
+            result.Roles = ";".join(roles) if roles else result.Roles
+            result.ElectronicSignatureFound = result.SignatureCount > 0
+            hints = {h for h in (result.Hints or "").split(";") if h}
+            hints |= {sig.Hint for sig in result.Signatures if sig.Hint}
+            result.Hints = ";".join(sorted(hints)) if hints else result.Hints
+
+    def _CollectImageRects(self, page) -> list[fitz.Rect]:
+        rects: list[fitz.Rect] = []
+        try:
+            images = page.get_images(full=True)
+        except Exception:
+            return rects
+        for img in images:
+            xref = img[0]
+            try:
+                rects.extend(page.get_image_rects(xref))
+            except Exception:
+                continue
+        return rects
+
+    def _FilterSignatureImageRects(self, rects: list[fitz.Rect], page_rect) -> list[fitz.Rect]:
+        if not rects:
+            return []
+        max_area = page_rect.width * page_rect.height * 0.35
+        filtered: list[fitz.Rect] = []
+        for rect in rects:
+            r = fitz.Rect(rect)
+            area = r.get_area()
+            if area <= 0:
+                continue
+            if area > max_area:
+                continue
+            width = max(1.0, float(r.width))
+            height = max(1.0, float(r.height))
+            aspect = width / height
+            if aspect < 1.3:
+                continue
+            filtered.append(r)
+        return filtered
+
+    def _CollectRetainerRoleAnchors(
+        self, lines: list[dict[str, float | str]]
+    ) -> dict[str, list[fitz.Rect]]:
+        anchors: dict[str, list[fitz.Rect]] = {"client": [], "firm": []}
+        for line in lines:
+            lower = str(line["lower_text"])
+            rect = fitz.Rect(line["x0"], line["y0"], line["x1"], line["y1"])
+            if any(pattern.search(lower) for pattern in self.RETAINER_CLIENT_PATTERNS):
+                anchors["client"].append(rect)
+            if any(pattern.search(lower) for pattern in self.RETAINER_FIRM_PATTERNS):
+                anchors["firm"].append(rect)
+        return anchors
+
+    def _HasRetainerSignatureCue(self, lines: list[dict[str, float | str]]) -> bool:
+        tokens = ("signature", "signed", "agreed", "accepted", "authorized", "attorney", "by:")
+        for line in lines:
+            lower = str(line["lower_text"])
+            if any(token in lower for token in tokens):
+                return True
+        return False
+
+    def _AssignRolesToImages(
+        self,
+        rects: list[fitz.Rect],
+        anchors: dict[str, list[fitz.Rect]],
+        existing_signatures: list[Signature],
+    ) -> list[str]:
+        roles: list[str] = []
+        for rect in rects:
+            client_score = self._RoleDistance(rect, anchors.get("client", []))
+            firm_score = self._RoleDistance(rect, anchors.get("firm", []))
+            if client_score is None and firm_score is None:
+                roles.append("unknown")
+            elif firm_score is None:
+                roles.append("client")
+            elif client_score is None:
+                roles.append("firm")
+            else:
+                roles.append("client" if client_score <= firm_score else "firm")
+
+        existing_client = any(sig.Role == "client" for sig in existing_signatures)
+        if not existing_client and "client" not in roles and rects:
+            lowest_index = max(range(len(rects)), key=lambda i: rects[i].y1)
+            roles[lowest_index] = "client"
+        if "firm" not in roles:
+            for idx, role in enumerate(roles):
+                if role == "unknown":
+                    roles[idx] = "firm"
+        return roles
+
+    def _RoleDistance(self, rect: fitz.Rect, anchors: list[fitz.Rect]) -> float | None:
+        if not anchors:
+            return None
+        best = None
+        for anchor in anchors:
+            vertical_gap = max(0.0, max(anchor.y0 - rect.y1, rect.y0 - anchor.y1))
+            horizontal_gap = max(0.0, max(anchor.x0 - rect.x1, rect.x0 - anchor.x1))
+            score = vertical_gap * 2.0 + horizontal_gap
+            if best is None or score < best:
+                best = score
+        return best
+
+    def _OverlapRatio(self, rect: fitz.Rect, other: fitz.Rect) -> float:
+        try:
+            inter = rect & other
+        except Exception:
+            return 0.0
+        if inter is None:
+            return 0.0
+        inter_area = inter.get_area()
+        if inter_area <= 0:
+            return 0.0
+        denom = max(1.0, min(rect.get_area(), other.get_area()))
+        return inter_area / denom
+
+    def _PdfTupleToRect(self, bbox: tuple[float, float, float, float], page_height: float) -> fitz.Rect:
+        x0, y0, x1, y1 = bbox
+        top = page_height - y1
+        bottom = page_height - y0
+        return fitz.Rect(x0, top, x1, bottom)
+
+    def _HasBBox(self, bbox: tuple[float, float, float, float] | None) -> bool:
+        if not bbox or len(bbox) != 4:
+            return False
+        x0, y0, x1, y1 = bbox
+        if x0 == 0 and y0 == 0 and x1 == 0 and y1 == 0:
+            return False
+        return (x1 - x0) > 0 and (y1 - y0) > 0
+
     def _FindRoleLineRect(
         self,
         page,

{sigdetect-0.5.2.dist-info → sigdetect-0.5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sigdetect
-Version: 0.5.2
+Version: 0.5.3
 Summary: Signature detection and role attribution for PDFs
 Author-email: BT Asmamaw <basmamaw@angeiongroup.com>
 License: MIT

{sigdetect-0.5.2.dist-info → sigdetect-0.5.3.dist-info}/RECORD

@@ -2,7 +2,7 @@ sigdetect/__init__.py,sha256=YvnTwlC1jfq83EhQS_1JjiiHK7_wJCCU1JvHv5E1qWY,573
 sigdetect/api.py,sha256=hDfa6z4SoHth1Dw9HDfSPiytMQrqu_oyBZlXBwSh9g4,11010
 sigdetect/cli.py,sha256=X5GqZ-PK67vz4OHN5r7h-V0hO886ZblUiUdKDuFowtU,10930
 sigdetect/config.py,sha256=3SP1rkcWBGXloCDFomBJRMRKZOvXuHQbhIBqpVrzYmY,8365
-sigdetect/cropping.py,sha256=IyiBfIEHBLvOv8t_d-O51BfpljTFpE-dG_RxDxJAzAo,16339
+sigdetect/cropping.py,sha256=6O7xuEU0hOlv0Wfb4kr2DJS-JPEw_kDNx4mLeYPuXl8,86869
 sigdetect/eda.py,sha256=S92G1Gjmepri__D0n_V6foq0lQgH-RXI9anW8A58jfw,4681
 sigdetect/logging_setup.py,sha256=LMF8ao_a-JwH0S522T6aYTFX3e8Ajjv_5ODS2YiBcHA,6404
 sigdetect/utils.py,sha256=T9rubLf5T9JmjOHYMOba1j34fhOJaWocAXccnGTxRUE,5198
@@ -14,11 +14,11 @@ sigdetect/detector/__init__.py,sha256=nT52mCI9s03Rso_RS86mm223rJfl5GlGDFsXwMJ3z3
 sigdetect/detector/base.py,sha256=L-iXWXqsTetDc4jRZo_wOdbNpKqOY20mX9FefrugdT0,263
 sigdetect/detector/base_detector.py,sha256=GmAgUWO_fQgIfnihZSoyhR3wpnwZ-X3hS0Kuyz4G6Ys,608
 sigdetect/detector/file_result_model.py,sha256=j2gTc9Sw3fJOHlexYsR_m5DiwHA8DzIzAMToESfvo4A,1767
-sigdetect/detector/pymupdf_engine.py,sha256=N6oxvUa-48VvvhjbMk0R0kfScsggNKS7u5FLSeBRfWw,17358
+sigdetect/detector/pymupdf_engine.py,sha256=ZcjMrCR6qxa4pvlvOf88OGWPQsCXnPmNN7yLyEv23Cc,27840
 sigdetect/detector/pypdf2_engine.py,sha256=kB8cIp_gMvCla0LIBi9sd19g0361Oc9TjCW_ZViUBJQ,47410
 sigdetect/detector/signature_model.py,sha256=T2Hmfkfz_hZsDzwOhepxfNmkedxQp3_XHdrP8yGKoCk,1322
-sigdetect-0.5.2.dist-info/METADATA,sha256=jLin7USVPqeA5tS7KCuPRRt1PLwdt-oJWhWuKSQa6hE,14131
-sigdetect-0.5.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-sigdetect-0.5.2.dist-info/entry_points.txt,sha256=iqtfKjBU44-omM7Sh-idGz2ahw19oAvpvSyKZVArG3o,48
-sigdetect-0.5.2.dist-info/top_level.txt,sha256=PKlfwUobkRC0viwiSXmhtw83G26FSNpimWYC1Uy00FY,10
-sigdetect-0.5.2.dist-info/RECORD,,
+sigdetect-0.5.3.dist-info/METADATA,sha256=lm6dyZlv6tS2L61G5u94D_vbPXQ3RHJPDRS5LlDDpc0,14131
+sigdetect-0.5.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+sigdetect-0.5.3.dist-info/entry_points.txt,sha256=iqtfKjBU44-omM7Sh-idGz2ahw19oAvpvSyKZVArG3o,48
+sigdetect-0.5.3.dist-info/top_level.txt,sha256=PKlfwUobkRC0viwiSXmhtw83G26FSNpimWYC1Uy00FY,10
+sigdetect-0.5.3.dist-info/RECORD,,