Fix Smoke Signal Surya OCR for new predictor API

smoke_signal/scripts/03_ocr_bakeoff.py

@@ -27,6 +27,7 @@ Usage:
 
 import argparse
 import csv
+import hashlib
 import json
 import sys
 import time
@@ -113,8 +114,34 @@ def _safe_load_surya_component(loader, checkpoint: Optional[str]):
 def load_surya_context(checkpoint: Optional[str] = None) -> Optional[dict]:
     """
     Load Surya OCR models once per run.
+    Tries modern predictor API first, then legacy API.
     Returns context dict or None if Surya import/loading fails.
     """
+    # New API (surya-ocr>=0.17 style)
+    try:
+        from surya.foundation import FoundationPredictor
+        from surya.detection import DetectionPredictor
+        from surya.recognition import RecognitionPredictor
+        try:
+            from surya.common.surya.schema import TaskNames
+            task_name = TaskNames.ocr_with_boxes
+        except Exception:
+            task_name = "ocr_with_boxes"
+
+        foundation_predictor = _safe_load_surya_component(FoundationPredictor, checkpoint)
+        det_predictor = DetectionPredictor()
+        rec_predictor = RecognitionPredictor(foundation_predictor)
+        return {
+            "api": "predictor-v2",
+            "task_name": task_name,
+            "det_predictor": det_predictor,
+            "rec_predictor": rec_predictor,
+            "checkpoint": checkpoint,
+        }
+    except Exception:
+        pass
+
+    # Legacy API (surya-ocr<=0.6 style)
     try:
         from surya.ocr import run_ocr
         from surya.model.detection.model import load_model as load_det_model
@@ -169,14 +196,23 @@ def _run_surya(image_path: Path, langs: list, surya_ctx: Optional[dict] = None)
 
     try:
         image = Image.open(str(image_path)).convert("RGB")
-        results = ctx["run"](
-            [image],
-            [langs],
-            ctx["det_model"],
-            ctx["det_processor"],
-            ctx["rec_model"],
-            ctx["rec_processor"],
-        )
+        if ctx.get("api") == "predictor-v2":
+            results = ctx["rec_predictor"](
+                [image],
+                task_names=[ctx["task_name"]],
+                det_predictor=ctx["det_predictor"],
+                highres_images=[image],
+                math_mode=True,
+            )
+        else:
+            results = ctx["run"](
+                [image],
+                [langs],
+                ctx["det_model"],
+                ctx["det_processor"],
+                ctx["rec_model"],
+                ctx["rec_processor"],
+            )
 
         page_result = results[0]
 
@@ -191,10 +227,13 @@ def _run_surya(image_path: Path, langs: list, surya_ctx: Optional[dict] = None)
             if text:
                 full_text.append(text)
                 confidences.append(conf)
+                bbox = getattr(line, "bbox", None)
+                if bbox is None:
+                    bbox = getattr(line, "polygon", None)
                 words.append({
                     "text":       text,
                     "confidence": round(conf, 4),
-                    "bbox":       line.bbox if hasattr(line, "bbox") else None,
+                    "bbox":       bbox,
                 })
 
         avg_conf = round(sum(confidences) / len(confidences), 4) if confidences else 0.0

smoke_signal_tab.py

@@ -735,23 +735,52 @@ def run_ocr() -> tuple:
 
     log = []
 
-    # Try to import Surya
+    # Try to import/load Surya (new predictor API first, then legacy API)
     surya = None
+    surya_error = None
+    log.append(log_line("Loading Surya models (may take a moment)..."))
     try:
-        from surya.ocr import run_ocr as surya_run
-        from surya.model.detection.model import load_model as load_det
-        from surya.model.detection.processor import load_processor as load_det_proc
-        from surya.model.recognition.model import load_model as load_rec
-        from surya.model.recognition.processor import load_processor as load_rec_proc
-        log.append(log_line("Loading Surya models (may take a moment)..."))
+        from surya.foundation import FoundationPredictor
+        from surya.detection import DetectionPredictor
+        from surya.recognition import RecognitionPredictor
+        try:
+            from surya.common.surya.schema import TaskNames
+            task_name = TaskNames.ocr_with_boxes
+        except Exception:
+            task_name = "ocr_with_boxes"
+
+        foundation_predictor = FoundationPredictor()
+        det_predictor = DetectionPredictor()
+        rec_predictor = RecognitionPredictor(foundation_predictor)
         surya = {
-            "run": surya_run,
-            "det_model": load_det(), "det_proc": load_det_proc(),
-            "rec_model": load_rec(), "rec_proc": load_rec_proc(),
+            "api": "predictor-v2",
+            "task_name": task_name,
+            "det_predictor": det_predictor,
+            "rec_predictor": rec_predictor,
         }
-        log.append(log_line("✓ Surya models loaded"))
-    except ImportError as e:
-        log.append(log_line(f"⚠ Surya unavailable ({e}) — falling back to text extraction only"))
+    except Exception as e:
+        surya_error = e
+        try:
+            from surya.ocr import run_ocr as surya_run
+            from surya.model.detection.model import load_model as load_det
+            from surya.model.detection.processor import load_processor as load_det_proc
+            from surya.model.recognition.model import load_model as load_rec
+            from surya.model.recognition.processor import load_processor as load_rec_proc
+            surya = {
+                "api": "legacy-v1",
+                "run": surya_run,
+                "det_model": load_det(),
+                "det_proc": load_det_proc(),
+                "rec_model": load_rec(),
+                "rec_proc": load_rec_proc(),
+            }
+        except Exception as legacy_error:
+            surya_error = f"{surya_error}; legacy={legacy_error}"
+
+    if surya:
+        log.append(log_line(f"✓ Surya models loaded ({surya['api']})"))
+    else:
+        log.append(log_line(f"⚠ Surya unavailable ({surya_error}) — falling back to text extraction only"))
 
     queue_rows = []
 
@@ -806,7 +835,23 @@ def run_ocr() -> tuple:
                     doc.close()
 
                     img = Image.open(render_path).convert("RGB")
-                    result = surya["run"]([img], [["en"]], surya["det_model"], surya["det_proc"], surya["rec_model"], surya["rec_proc"])
+                    if surya["api"] == "predictor-v2":
+                        result = surya["rec_predictor"](
+                            [img],
+                            task_names=[surya["task_name"]],
+                            det_predictor=surya["det_predictor"],
+                            highres_images=[img],
+                            math_mode=True,
+                        )
+                    else:
+                        result = surya["run"](
+                            [img],
+                            [["en"]],
+                            surya["det_model"],
+                            surya["det_proc"],
+                            surya["rec_model"],
+                            surya["rec_proc"],
+                        )
                     page_result = result[0]
 
                     regions = []
@@ -814,7 +859,10 @@ def run_ocr() -> tuple:
                         txt = line.text.strip()
                         if txt:
                             c = float(line.confidence) if hasattr(line, "confidence") else 1.0
-                            regions.append({"text": txt, "confidence": round(c,4), "bbox": line.bbox, "word_count": len(txt.split())})
+                            bbox = getattr(line, "bbox", None)
+                            if bbox is None:
+                                bbox = getattr(line, "polygon", None)
+                            regions.append({"text": txt, "confidence": round(c,4), "bbox": bbox, "word_count": len(txt.split())})
 
                     conf = sum(r["confidence"]*r["word_count"] for r in regions) / max(sum(r["word_count"] for r in regions), 1) if regions else 0.0
                     conf = round(conf, 4)