sigdetect 0.5.1__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/wet_detection.py

@@ -94,6 +94,17 @@ def apply_wet_detection(
     original_mixed = file_result.MixedContent
     try:
         added = _detect(pdf_path, configuration, file_result, logger=logger)
+        if added and configuration.Profile == "hipaa":
+            updated = False
+            for signature in file_result.Signatures:
+                if signature.RenderType == "wet" and (signature.Role or "unknown") == "unknown":
+                    signature.Role = "patient"
+                    signature.Scores = {"patient": int(signature.Score or 0)}
+                    signature.Evidence = list(signature.Evidence or [])
+                    signature.Evidence.append("role_default:patient")
+                    updated = True
+            if updated:
+                _refresh_metadata(file_result)
         if not added:
             _mark_manual_review(file_result, "NoHighConfidenceWetSignature")
         return added
@@ -136,6 +147,18 @@ def _detect(
                     scale=configuration.WetOcrDpi / 72.0,
                 )
             )
+            if not candidates:
+                candidates = list(
+                    _build_candidates(
+                        ocr_lines,
+                        image=image,
+                        page_rect=page.rect,
+                        pix_width=pixmap.width,
+                        pix_height=pixmap.height,
+                        scale=configuration.WetOcrDpi / 72.0,
+                        min_y_ratio=0.2,
+                    )
+                )
             candidates.extend(_image_candidates(page))
             candidates = _filter_candidates_for_page(candidates)
             accepted = [
@@ -247,6 +270,7 @@ def _build_candidates(
     pix_width: int,
     pix_height: int,
     scale: float,
+    min_y_ratio: float = 0.4,
 ) -> Iterable[WetCandidate]:
     for line in lines:
         normalized = line.text.lower()
@@ -255,7 +279,7 @@ def _build_candidates(
         if len(normalized) > 80:
             # Ignore long paragraph-like OCR lines
             continue
-        if (line.bottom / pix_height) < 0.4:
+        if (line.bottom / pix_height) < min_y_ratio:
             # Ignore lines in the upper section of the page
             continue
         role = _infer_role(normalized)
@@ -338,28 +362,33 @@ def _expand_bbox(
 ) -> tuple[float, float, float, float]:
     x0 = line.left / scale
     x1 = line.right / scale
-    y1 = (pix_height - line.top) / scale
+    y_top = (pix_height - line.top) / scale
+    y_bottom = (pix_height - line.bottom) / scale
 
     pad_x = max(14.0, (x1 - x0) * 0.25)
     left = max(page_rect.x0, x0 - pad_x)
     right = min(page_rect.x1, x1 + pad_x)
 
     gap = 14.0
-    signature_height = 70.0
-    top = min(page_rect.y1, y1 + gap)
-    bottom = min(page_rect.y1, top + signature_height)
-
-    if bottom <= top:
-        bottom = min(page_rect.y1, top + signature_height)
+    line_height = max(1.0, (line.bottom - line.top) / scale)
+    signature_height = max(70.0, line_height * 6.0)
+    upper = min(page_rect.y1, y_bottom - gap)
+    upper = max(page_rect.y0, upper)
+    lower = max(page_rect.y0, upper - signature_height)
 
     if stroke_y is not None:
-        # Anchor to the detected stroke under the OCR label when available.
+        # Anchor to the detected stroke (signature line) beneath the label.
         sy = (pix_height - stroke_y) / scale
-        if sy < top:
-            top = sy
-        bottom = max(bottom, sy + signature_height)
+        field_lower = min(page_rect.y1, max(page_rect.y0, sy + 2.0))
+        field_upper = min(page_rect.y1, y_bottom - gap)
+        if field_upper > field_lower + 6.0:
+            lower = field_lower
+            upper = field_upper
+        else:
+            upper = min(page_rect.y1, field_lower + signature_height)
+            lower = max(page_rect.y0, upper - signature_height)
 
-    return (float(left), float(top), float(right), float(bottom))
+    return (float(left), float(lower), float(right), float(upper))
 
 
 def _stroke_under_line(image: Image.Image, line: OcrLine) -> tuple[bool, float | None]:
@@ -513,14 +542,19 @@ def _signature_rank(signature: Signature) -> tuple[int, int, int]:
 
 def _dedupe_wet_signatures(signatures: Sequence[Signature]) -> list[Signature]:
     best_by_role: dict[str, Signature] = {}
+    best_unknown: Signature | None = None
     for signature in signatures:
         role = (signature.Role or "unknown").strip().lower()
         if role == "unknown":
+            if best_unknown is None or _signature_rank(signature) > _signature_rank(best_unknown):
+                best_unknown = signature
             continue
         existing = best_by_role.get(role)
         if existing is None or _signature_rank(signature) > _signature_rank(existing):
             best_by_role[role] = signature
-    return sorted(best_by_role.values(), key=lambda sig: (int(sig.Page or 0), sig.Role or ""))
+    if best_by_role:
+        return sorted(best_by_role.values(), key=lambda sig: (int(sig.Page or 0), sig.Role or ""))
+    return [best_unknown] if best_unknown is not None else []
 
 
 def _mark_manual_review(file_result: FileResult, reason: str) -> None:

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

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

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

@@ -2,11 +2,11 @@ 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=HfOJrV2Xv9Eo0lCIl3mukz49agKB6h2TML99B0qQJNc,8837
+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
-sigdetect/wet_detection.py,sha256=zvi11XUmm_xLZ4BLvxInwMQg8YLcyQzEYAM9QSdJOIs,18259
+sigdetect/wet_detection.py,sha256=ofKijykm4fKrvFaVkEkPPKL9iKeRNvlAiKkD2vHxD8k,20025
 sigdetect/data/role_rules.retainer.yml,sha256=IFdwKnDBXR2cTkdfrsZ6ku6CXD8S_dg5A3vKRKLW5h8,2532
 sigdetect/data/role_rules.yml,sha256=HuLKsZR_A6sD9XvY4NHiY_VG3dS5ERNCBF9-Mxawomw,2751
 sigdetect/data/vendor_patterns.yml,sha256=NRbZNQxcx_GuL6n1jAphBn6MM6ChCpeWGCsjbRx-PEo,384
@@ -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.1.dist-info/METADATA,sha256=_Jnyl9_A1yZUrKwWxUxVB-9rcMG3MdUqiN5WX_zlpqQ,14131
-sigdetect-0.5.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-sigdetect-0.5.1.dist-info/entry_points.txt,sha256=iqtfKjBU44-omM7Sh-idGz2ahw19oAvpvSyKZVArG3o,48
-sigdetect-0.5.1.dist-info/top_level.txt,sha256=PKlfwUobkRC0viwiSXmhtw83G26FSNpimWYC1Uy00FY,10
-sigdetect-0.5.1.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,,