omnius 1.0.638 → 1.0.640

package/dist/scripts/ocr-advanced.py

@@ -37,6 +37,9 @@ import os
 import json
 import csv
 import argparse
+import signal
+import time
+from collections import OrderedDict
 from pathlib import Path
 
 def check_deps():
@@ -168,34 +171,105 @@ PSM_MODES = {
     11: "sparse",
 }
 
+# Advanced OCR is a bounded recovery pipeline, not a blind Cartesian product.
+# A 327x333 crop previously paid for 24 variants/PSMs and two Tesseract child
+# processes per attempt. Small inputs now begin with two high-yield attempts;
+# larger/low-evidence images expand only while budget remains.
+SMALL_CROP_AREA_PX = 512_000
+MEDIUM_IMAGE_AREA_PX = 2_000_000
+MAX_PIPELINE_DEADLINE_MS = 80_000
+MAX_TESSERACT_ATTEMPT_SECONDS = 12.0
+MIN_TESSERACT_ATTEMPT_SECONDS = 0.25
+ACTIVE_DEADLINE = None
 
-# ---------------------------------------------------------------------------
-# OCR execution
-# ---------------------------------------------------------------------------
 
-def run_tesseract(binary_img, language="eng", psm=6):
-    """Run Tesseract on a preprocessed binary image.
-    Returns (text, confidence, line_count)."""
-    pil_img = Image.fromarray(binary_img)
-    config = f"--psm {psm}"
+class OcrPipelineTimeout(RuntimeError):
+    pass
 
-    # Engine failures are not blank documents. Let callers distinguish a real
-    # low-information image from a missing language pack or broken Tesseract.
-    text = pytesseract.image_to_string(pil_img, lang=language, config=config).strip()
 
-    line_count = len([l for l in text.split("\n") if l.strip()])
+class OcrPipelineCancelled(RuntimeError):
+    pass
 
-    # Get confidence via image_to_data
-    try:
-        data = pytesseract.image_to_data(
-            pil_img, lang=language, config=config,
-            output_type=pytesseract.Output.DICT,
+
+def cancellation_signal_handler(signum, _frame):
+    raise OcrPipelineCancelled(f"received signal {signum}")
+
+
+class OcrDeadline:
+    def __init__(self, deadline_ms):
+        self.deadline_ms = max(1_000, min(int(deadline_ms), MAX_PIPELINE_DEADLINE_MS))
+        self.started = time.monotonic()
+
+    def remaining_seconds(self):
+        return self.deadline_ms / 1000.0 - (time.monotonic() - self.started)
+
+    def check(self, stage):
+        if self.remaining_seconds() <= 0:
+            raise OcrPipelineTimeout(f"OCR deadline exceeded during {stage}")
+
+    def tesseract_timeout_seconds(self):
+        self.check("Tesseract scheduling")
+        return max(
+            MIN_TESSERACT_ATTEMPT_SECONDS,
+            min(MAX_TESSERACT_ATTEMPT_SECONDS, self.remaining_seconds()),
+        )
+
+
+def diagnostic(code, message, deadline, stage, attempts_completed=0, attempts_planned=0):
+    return {
+        "schema": "omnius.ocr-diagnostic.v1",
+        "code": code,
+        "message": message,
+        "stage": stage,
+        "deadline_ms": deadline.deadline_ms,
+        "attempts_completed": attempts_completed,
+        "attempts_planned": attempts_planned,
+    }
+
+
+# ---------------------------------------------------------------------------
+# OCR execution
+# ---------------------------------------------------------------------------
+
+def text_from_tesseract_data(data):
+    """Reconstruct line breaks from one TSV pass; do not spawn Tesseract twice."""
+    lines = OrderedDict()
+    texts = data.get("text", [])
+    for index, raw_text in enumerate(texts):
+        text = str(raw_text or "").strip()
+        if not text:
+            continue
+        key = tuple(
+            int(data.get(field, [0] * len(texts))[index] or 0)
+            for field in ("block_num", "par_num", "line_num")
         )
-        confs = [int(c) for c in data["conf"] if int(c) >= 0]
-        avg_conf = sum(confs) / len(confs) if confs else 0.0
-    except Exception:
-        avg_conf = 0.0
+        lines.setdefault(key, []).append(text)
+    return "\n".join(" ".join(words) for words in lines.values()).strip()
+
 
+def run_tesseract(binary_img, deadline, language="eng", psm=6):
+    """Run one bounded Tesseract TSV pass and derive text plus confidence."""
+    deadline.check("Tesseract")
+    pil_img = Image.fromarray(binary_img)
+    config = f"--psm {psm}"
+    data = pytesseract.image_to_data(
+        pil_img,
+        lang=language,
+        config=config,
+        output_type=pytesseract.Output.DICT,
+        timeout=deadline.tesseract_timeout_seconds(),
+    )
+    text = text_from_tesseract_data(data)
+    confs = []
+    for value in data.get("conf", []):
+        try:
+            confidence = float(value)
+        except (TypeError, ValueError):
+            continue
+        if confidence >= 0:
+            confs.append(confidence)
+    avg_conf = sum(confs) / len(confs) if confs else 0.0
+    line_count = len([line for line in text.split("\n") if line.strip()])
     return text, avg_conf, line_count
 
 
@@ -226,6 +300,28 @@ def extract_pixel_region(gray, x, y, w, h):
     return gray[y:y+h, x:x+w]
 
 
+def build_ocr_plan(image_area_px, single_psm=None):
+    """Return the smallest credible variant/PSM plan for the effective image."""
+    psm_modes = [single_psm] if single_psm else (
+        [6] if image_area_px <= SMALL_CROP_AREA_PX
+        else [6, 11] if image_area_px <= MEDIUM_IMAGE_AREA_PX
+        else [6, 11, 4]
+    )
+    variants = (
+        ["otsu", "adaptive_fine"] if image_area_px <= SMALL_CROP_AREA_PX
+        else ["otsu", "adaptive_fine", "denoise", "sharpen_unsharp"]
+        if image_area_px <= MEDIUM_IMAGE_AREA_PX
+        else list(ALL_VARIANTS.keys())
+    )
+    # OTSU/PSM6 is deliberately first: a legible result ends the search
+    # instead of paying for redundant variants that cannot improve the answer.
+    return [(variant, psm) for psm in psm_modes for variant in variants]
+
+
+def has_sufficient_evidence(text, confidence, line_count):
+    return len(text.strip()) >= 8 and confidence >= 70.0 and line_count >= 1
+
+
 # ---------------------------------------------------------------------------
 # Output writers
 # ---------------------------------------------------------------------------
@@ -295,142 +391,139 @@ def write_all_outputs(text, base_name, output_dir):
 # Main pipeline
 # ---------------------------------------------------------------------------
 
-def run_pipeline(image_path, language="eng", do_regions=False, debug_dir=None,
-                 single_psm=None, pixel_region=None, output_dir=None):
-    """Run the full multi-variant, multi-PSM OCR pipeline."""
-
-    # Load image
-    img = cv2.imread(image_path)
-    if img is None:
-        return {"error": f"Could not load image: {image_path}"}
-
-    h_orig, w_orig = img.shape[:2]
-    gray = to_grayscale(img)
-
-    # Upscale 2x
-    gray_2x = upscale_2x(gray)
-
-    # If a pixel region is specified, crop before processing
-    if pixel_region:
-        rx, ry, rw, rh = pixel_region
-        # Scale region coords to match 2x upscale
-        gray_2x = extract_pixel_region(gray_2x, rx * 2, ry * 2, rw * 2, rh * 2)
-
-    # Determine PSM modes to test
-    psm_modes = [single_psm] if single_psm else [4, 6, 11]
-
-    # Generate all variants and run OCR
+def run_variant_plan(gray, plan, deadline, language, debug_dir=None, debug_prefix="full"):
+    """Run a bounded plan, stopping early once a legible result is proven."""
     all_results = {}
     ocr_errors = []
     best_key = None
     best_score = -1
+    early_exit = False
 
-    for vname, vfunc in ALL_VARIANTS.items():
+    for vname, psm in plan:
+        deadline.check("preprocessing")
+        key = f"{vname}_psm{psm}"
         try:
-            binary = vfunc(gray_2x)
-        except Exception:
+            binary = ALL_VARIANTS[vname](gray)
+        except Exception as error:
+            ocr_errors.append(f"{key}: preprocessing failed: {error}")
             continue
-
-        # Save debug images
         if debug_dir:
             os.makedirs(debug_dir, exist_ok=True)
-            cv2.imwrite(os.path.join(debug_dir, f"full_{vname}.png"), binary)
-
-        for psm in psm_modes:
-            key = f"{vname}_psm{psm}"
-            try:
-                text, confidence, line_count = run_tesseract(binary, language, psm)
-            except Exception as error:
-                ocr_errors.append(f"{key}: {error}")
-                continue
-            char_count = len(text)
-            score = compute_score(text, confidence, line_count)
-
-            all_results[key] = {
-                "text": text,
-                "chars": char_count,
-                "lines": line_count,
-                "confidence": round(confidence, 1),
-                "score": round(score, 1),
-            }
-
-            if score > best_score:
-                best_score = score
-                best_key = key
-
-    if not best_key:
-        detail = ocr_errors[-1] if ocr_errors else "no preprocessing variant completed"
-        return {"error": f"Tesseract failed for every OCR variant: {detail}"}
-
-    best = all_results[best_key]
-    result = {
-        "text": best["text"],
-        "confidence": best["confidence"],
-        "variant": best_key,
-        "chars": best["chars"],
-        "lines": best["lines"],
-        "score": best["score"],
-        "image_size": f"{w_orig}x{h_orig}",
-        "variants_tested": len(all_results),
-        "all_variants": all_results,
-    }
-
-    # Region-based OCR
-    if do_regions:
-        regions = {}
-        region_defs = {
-            "header": (0, 35),
-            "body": (30, 80),
-            "footer": (75, 100),
+            cv2.imwrite(os.path.join(debug_dir, f"{debug_prefix}_{vname}.png"), binary)
+        try:
+            text, confidence, line_count = run_tesseract(binary, deadline, language, psm)
+        except OcrPipelineTimeout:
+            raise
+        except OcrPipelineCancelled:
+            raise
+        except Exception as error:
+            ocr_errors.append(f"{key}: {error}")
+            continue
+        char_count = len(text)
+        score = compute_score(text, confidence, line_count)
+        all_results[key] = {
+            "text": text,
+            "chars": char_count,
+            "lines": line_count,
+            "confidence": round(confidence, 1),
+            "score": round(score, 1),
         }
+        if score > best_score:
+            best_score = score
+            best_key = key
+        if has_sufficient_evidence(text, confidence, line_count):
+            early_exit = True
+            break
 
-        for rname, (y_start, y_end) in region_defs.items():
-            region_gray = extract_region(gray_2x, y_start, y_end)
-
-            if debug_dir:
-                cv2.imwrite(os.path.join(debug_dir, f"region_{rname}.png"), region_gray)
-
-            # Test all variants on each region for best accuracy
-            region_best = ""
-            region_best_score = -1
-
-            for vname in ["otsu", "denoise", "adaptive_fine", "sharpen_unsharp"]:
-                if vname not in ALL_VARIANTS:
-                    continue
-                try:
-                    binary = ALL_VARIANTS[vname](region_gray)
-                except Exception:
-                    continue
+    return all_results, ocr_errors, best_key, early_exit
 
-                if debug_dir:
-                    cv2.imwrite(os.path.join(debug_dir, f"region_{rname}_{vname}.png"), binary)
 
-                try:
-                    text, conf, lc = run_tesseract(binary, language, 6)
-                except Exception:
-                    continue
-                score = compute_score(text, conf, lc)
-                if score > region_best_score:
-                    region_best_score = score
-                    region_best = text
-
-            regions[rname] = region_best
-
-        result["regions"] = regions
+def run_pipeline(image_path, deadline, language="eng", do_regions=False, debug_dir=None,
+                 single_psm=None, pixel_region=None, output_dir=None):
+    """Run bounded OCR. The effective crop controls plan size, not the full frame."""
+    deadline.check("image load")
+    img = cv2.imread(image_path)
+    if img is None:
+        return {"error": f"Could not load image: {image_path}"}
 
-    if debug_dir:
-        result["debug_dir"] = debug_dir
+    h_orig, w_orig = img.shape[:2]
+    gray = to_grayscale(img)
+    if pixel_region:
+        rx, ry, rw, rh = pixel_region
+        if rx >= w_orig or ry >= h_orig:
+            return {"error": "Requested OCR region lies outside the image"}
+        gray = extract_pixel_region(gray, rx, ry, rw, rh)
+    if gray.size == 0:
+        return {"error": "Requested OCR region is empty"}
+
+    effective_area = int(gray.shape[0] * gray.shape[1])
+    deadline.check("image conditioning")
+    gray_2x = upscale_2x(gray)
+    plan = build_ocr_plan(effective_area, single_psm)
+    attempts_completed = 0
+    try:
+        all_results, ocr_errors, best_key, early_exit = run_variant_plan(
+            gray_2x, plan, deadline, language, debug_dir
+        )
+        attempts_completed = len(all_results)
+        if not best_key:
+            detail = ocr_errors[-1] if ocr_errors else "no preprocessing variant completed"
+            return {"error": f"Tesseract failed for every bounded OCR attempt: {detail}"}
+
+        best = all_results[best_key]
+        result = {
+            "text": best["text"],
+            "confidence": best["confidence"],
+            "variant": best_key,
+            "chars": best["chars"],
+            "lines": best["lines"],
+            "score": best["score"],
+            "image_size": f"{w_orig}x{h_orig}",
+            "variants_tested": len(all_results),
+            "all_variants": all_results,
+            "strategy": {
+                "effective_area_px": effective_area,
+                "attempts_planned": len(plan),
+                "attempts_completed": attempts_completed,
+                "early_exit": early_exit,
+                "deadline_ms": deadline.deadline_ms,
+            },
+        }
 
-    # Write output files if output_dir specified
-    if output_dir:
-        base_name = Path(image_path).stem
-        files = write_all_outputs(best["text"], base_name, output_dir)
-        result["output_files"] = files
+        if do_regions:
+            regions = {}
+            region_defs = {"header": (0, 35), "body": (30, 80), "footer": (75, 100)}
+            for rname, (y_start, y_end) in region_defs.items():
+                deadline.check(f"region {rname}")
+                region_gray = extract_region(gray_2x, y_start, y_end)
+                # Region requests use at most two high-yield attempts. The
+                # main result already provides full-frame coverage.
+                region_plan = build_ocr_plan(region_gray.shape[0] * region_gray.shape[1], single_psm)[:2]
+                region_results, _errors, region_best_key, _early_exit = run_variant_plan(
+                    region_gray, region_plan, deadline, language, debug_dir, f"region_{rname}"
+                )
+                regions[rname] = region_results[region_best_key]["text"] if region_best_key else ""
+            result["regions"] = regions
 
-    return result
+        if debug_dir:
+            result["debug_dir"] = debug_dir
+        if output_dir:
+            base_name = Path(image_path).stem
+            result["output_files"] = write_all_outputs(best["text"], base_name, output_dir)
+        return result
+    except OcrPipelineTimeout as error:
+        return {
+            "error": str(error),
+            "diagnostic": diagnostic("ocr_timeout", str(error), deadline, "pipeline", attempts_completed, len(plan)),
+        }
+    except OcrPipelineCancelled as error:
+        return {
+            "error": "Advanced OCR cancelled",
+            "diagnostic": diagnostic("ocr_cancelled", str(error), deadline, "pipeline", attempts_completed, len(plan)),
+        }
 
 
-def run_batch(images_dir, language="eng", do_regions=False, debug_dir=None,
+def run_batch(images_dir, deadline, language="eng", do_regions=False, debug_dir=None,
               output_dir=None):
     """Process all images in a directory."""
     images_dir = os.path.abspath(images_dir)
@@ -450,10 +543,18 @@ def run_batch(images_dir, language="eng", do_regions=False, debug_dir=None,
         return {"error": f"No image files found in {images_dir}"}
 
     for img_file in image_files:
+        try:
+            deadline.check("batch scheduling")
+        except OcrPipelineTimeout as error:
+            return {
+                "error": str(error),
+                "diagnostic": diagnostic("ocr_timeout", str(error), deadline, "batch", len(batch_results), len(image_files)),
+            }
         img_path = os.path.join(images_dir, img_file)
         img_debug = os.path.join(debug_dir, Path(img_file).stem) if debug_dir else None
         result = run_pipeline(
             img_path,
+            deadline,
             language=language,
             do_regions=do_regions,
             debug_dir=img_debug,
@@ -469,6 +570,14 @@ def run_batch(images_dir, language="eng", do_regions=False, debug_dir=None,
             "output_files": result.get("output_files"),
             "error": result.get("error"),
         }
+        if result.get("diagnostic", {}).get("code") in {"ocr_timeout", "ocr_cancelled"}:
+            return {
+                "error": result["error"],
+                "diagnostic": result["diagnostic"],
+                "batch": True,
+                "images_processed": len(batch_results),
+                "results": batch_results,
+            }
 
     # Write summary
     summary_path = os.path.join(out_dir, "OCR_PROCESSING_SUMMARY.md")
@@ -497,6 +606,7 @@ def run_batch(images_dir, language="eng", do_regions=False, debug_dir=None,
 
 
 def main():
+    global ACTIVE_DEADLINE
     parser = argparse.ArgumentParser(
         description="Advanced multi-variant OCR pipeline for omnius"
     )
@@ -520,13 +630,20 @@ def main():
                         help="Write TXT + CSV + PDF outputs to this directory")
     parser.add_argument("--batch", action="store_true",
                         help="Process all images in a directory")
+    parser.add_argument("--deadline-ms", type=int, default=MAX_PIPELINE_DEADLINE_MS,
+                        help="Bound total OCR work; clamped to the managed maximum")
 
     args = parser.parse_args()
+    deadline = OcrDeadline(args.deadline_ms)
+    ACTIVE_DEADLINE = deadline
+    signal.signal(signal.SIGTERM, cancellation_signal_handler)
+    signal.signal(signal.SIGINT, cancellation_signal_handler)
 
     # Batch mode
     if args.batch or os.path.isdir(args.image):
         result = run_batch(
             args.image,
+            deadline,
             language=args.language,
             do_regions=args.regions,
             debug_dir=args.debug_dir,
@@ -558,6 +675,7 @@ def main():
 
     result = run_pipeline(
         args.image,
+        deadline,
         language=args.language,
         do_regions=args.regions,
         debug_dir=args.debug_dir,
@@ -578,4 +696,19 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    try:
+        main()
+    except OcrPipelineTimeout as error:
+        deadline = ACTIVE_DEADLINE or OcrDeadline(MAX_PIPELINE_DEADLINE_MS)
+        print(json.dumps({
+            "error": str(error),
+            "diagnostic": diagnostic("ocr_timeout", str(error), deadline, "entrypoint"),
+        }))
+        sys.exit(124)
+    except OcrPipelineCancelled as error:
+        deadline = ACTIVE_DEADLINE or OcrDeadline(MAX_PIPELINE_DEADLINE_MS)
+        print(json.dumps({
+            "error": "Advanced OCR cancelled",
+            "diagnostic": diagnostic("ocr_cancelled", str(error), deadline, "entrypoint"),
+        }))
+        sys.exit(130)

package/dist/scripts/transcribe-file.py

@@ -8,16 +8,65 @@ stdout: JSON {"text": "...", "duration": null, "segments": []}
 
 ASR is GPU-first: CPU fallback is refused unless OMNIUS_ASR_ALLOW_CPU=1.
 """
-import sys, os, json, warnings
+import sys, os, json, math, struct, warnings, wave
 
 warnings.filterwarnings("ignore")
 os.environ.setdefault("PYTHONWARNINGS", "ignore")
 
-try:
-    import whisper
-except Exception as e:
-    print(json.dumps({"error": "deps_missing", "message": str(e)}))
-    sys.exit(0)
+PCM16_SILENCE_MAX_PEAK = 4
+PCM16_SILENCE_MAX_RMS = 1.0
+PCM16_ACTIVE_SAMPLE_THRESHOLD = 8
+
+
+def exact_pcm16_silence(path):
+    """Return typed no-speech evidence for exact PCM16/16k/mono WAV only.
+
+    This is intentionally not VAD. It reads user bytes but never rewrites,
+    normalizes, decodes another media format, or instantiates Whisper.
+    """
+    try:
+        with wave.open(path, "rb") as wav:
+            if (
+                wav.getcomptype() != "NONE"
+                or wav.getnchannels() != 1
+                or wav.getsampwidth() != 2
+                or wav.getframerate() != 16000
+            ):
+                return None
+            frames = wav.readframes(wav.getnframes())
+    except (wave.Error, OSError, EOFError):
+        return None
+    sample_count = len(frames) // 2
+    if sample_count == 0:
+        metrics = {
+            "sampleRateHz": 16000, "channels": 1, "bitsPerSample": 16,
+            "sampleCount": 0, "durationMs": 0.0, "peakPcm16": 0,
+            "rmsPcm16": 0.0, "activeSampleCount": 0, "activeSampleRatio": 0.0,
+        }
+    else:
+        samples = struct.iter_unpack("<h", frames[: sample_count * 2])
+        total_squares = 0
+        peak = 0
+        active = 0
+        for (sample,) in samples:
+            magnitude = abs(sample)
+            total_squares += sample * sample
+            peak = max(peak, magnitude)
+            if magnitude >= PCM16_ACTIVE_SAMPLE_THRESHOLD:
+                active += 1
+        metrics = {
+            "sampleRateHz": 16000, "channels": 1, "bitsPerSample": 16,
+            "sampleCount": sample_count, "durationMs": sample_count / 16.0,
+            "peakPcm16": peak, "rmsPcm16": math.sqrt(total_squares / sample_count),
+            "activeSampleCount": active, "activeSampleRatio": active / sample_count,
+        }
+    if (
+        metrics["peakPcm16"] <= PCM16_SILENCE_MAX_PEAK
+        and metrics["rmsPcm16"] <= PCM16_SILENCE_MAX_RMS
+        and metrics["activeSampleCount"] == 0
+    ):
+        return {"kind": "no_speech", "reason": "digital_silence", "text": "", "signal": metrics}
+    return None
 
 
 def main() -> None:
@@ -33,8 +82,14 @@ def main() -> None:
         print(json.dumps({"error": "file_not_found", "path": path or ""}))
         return
 
+    no_speech = exact_pcm16_silence(path)
+    if no_speech is not None:
+        print(json.dumps({**no_speech, "duration": no_speech["signal"]["durationMs"] / 1000.0, "segments": []}))
+        return
+
     model_name = data.get("model") or "tiny"
     try:
+        import whisper
         device = os.environ.get("OMNIUS_ASR_DEVICE", "cuda").strip().lower() or "cuda"
         allow_cpu = os.environ.get("OMNIUS_ASR_ALLOW_CPU", "").strip().lower() in ("1", "true", "yes", "on")
         if device == "auto":

package/dist/update-worker.js

@@ -293080,7 +293080,6 @@ var MAX_IMAGE_BYTES = 8 * 1024 * 1024;
 
 // packages/execution/dist/tools/ocr-image-advanced.js
 init_process_async();
-var OCR_PIPELINE_TIMEOUT_MS = 5 * 6e4;
 
 // packages/execution/dist/tools/browser-action.js
 init_process_lifecycle();