feat: image extraction via in-Space vision model (MiniCPM-V-4.6)

Add image -> text extraction so users can drop in a document or ID image and
have the fields extracted, then redacted by the existing core.

- redac/vision.py: extract_text_from_image() loads MiniCPM-V-4.6 via
transformers and runs under @spaces.GPU (ZeroGPU). REDAC_MOCK=1 returns a
canned extraction for GPU-less local UI testing.
- app.py: split into Text and Image tabs sharing one redaction core; image
flow shows raw extracted fields, redacted output, entity table, rehydrate.
- redac/detect.py: phone recognizer no longer matches ISO/common dates.
- requirements.txt: transformers, torchvision, accelerate, sentencepiece,
pillow, spaces.

Co-authored-by: OpenAI Codex <codex@openai.com>

app.py

@@ -1,16 +1,24 @@
 """Redac — a local privacy gateway.
 
-V1 (text): paste confidential text, Redac detects PII locally and produces a
-reversibly-redacted version plus an entity table. The redacted text is what
-you would safely hand to any downstream model; the mapping stays local so the
-answer can be rehydrated.
-
-All compute runs in-process (in-Space). No external API calls.
+Two entry points, one redaction core:
+  - Text:  paste confidential text -> detect PII -> reversibly redact.
+  - Image: upload a document/ID image -> a local vision model extracts the
+           fields -> the extracted text is redacted the same way.
+
+The redacted text is what you would safely hand to a downstream LLM; the
+mapping stays local so any answer can be rehydrated. All compute runs
+in-Space (vision model on ZeroGPU). No external API calls.
 """
 
 import gradio as gr
 
-from redac import detect_entities, redact, rehydrate, DEFAULT_LABELS
+from redac import (
+    detect_entities,
+    redact,
+    rehydrate,
+    extract_text_from_image,
+    DEFAULT_LABELS,
+)
 
 EXAMPLE = (
     "Patient John A. Doe, DOB 1985-04-12, was admitted on 2026-06-01. "
@@ -19,69 +27,105 @@ EXAMPLE = (
 )
 
 
-def run_redaction(text, labels, threshold):
+def _redact_text(text, labels, threshold):
     entities = detect_entities(text, labels=labels or DEFAULT_LABELS, threshold=threshold)
     redacted, mapping = redact(text, entities)
     table = [[e.label, e.text, f"{e.score:.2f}", e.source] for e in entities]
     summary = f"{len(entities)} PII span(s) redacted into {len(mapping)} placeholder(s)."
-    # mapping is returned into state so rehydrate can use it; never shown raw.
     return redacted, table, summary, mapping
 
 
+def run_text(text, labels, threshold):
+    return _redact_text(text, labels, threshold)
+
+
+def run_image(image, labels, threshold):
+    extracted = extract_text_from_image(image)
+    if not extracted:
+        return "", "", [], "No image / nothing extracted.", {}
+    redacted, table, summary, mapping = _redact_text(extracted, labels, threshold)
+    return extracted, redacted, table, summary, mapping
+
+
 def do_rehydrate(redacted_text, mapping):
     if not mapping:
         return "Run a redaction first."
     return rehydrate(redacted_text, mapping)
 
 
-with gr.Blocks(title="Redac", theme=gr.themes.Soft()) as demo:
+with gr.Blocks(title="Redac") as demo:
     gr.Markdown(
         "# 🖍️ Redac\n"
-        "**A local privacy gateway.** Detect and redact PII *before* text reaches "
-        "a downstream model. Redaction is reversible: the mapping stays local."
+        "**A local privacy gateway.** Detect and redact PII *before* it reaches "
+        "a downstream model. Reversible: the mapping stays local."
     )
 
-    mapping_state = gr.State({})
-
-    with gr.Row():
-        with gr.Column():
-            inp = gr.Textbox(
-                label="Confidential text",
-                placeholder="Paste a document, message, or record...",
-                lines=10,
-                value=EXAMPLE,
-            )
-            labels = gr.Dropdown(
-                label="PII types to detect",
-                choices=DEFAULT_LABELS,
-                value=DEFAULT_LABELS,
-                multiselect=True,
-            )
-            threshold = gr.Slider(
-                0.1, 0.9, value=0.45, step=0.05, label="Detection threshold"
+    with gr.Tabs():
+        # --- Text tab --------------------------------------------------------
+        with gr.Tab("Text"):
+            t_map = gr.State({})
+            with gr.Row():
+                with gr.Column():
+                    t_in = gr.Textbox(
+                        label="Confidential text",
+                        placeholder="Paste a document, message, or record...",
+                        lines=10,
+                        value=EXAMPLE,
+                    )
+                    t_labels = gr.Dropdown(
+                        label="PII types", choices=DEFAULT_LABELS,
+                        value=DEFAULT_LABELS, multiselect=True,
+                    )
+                    t_thr = gr.Slider(0.1, 0.9, value=0.45, step=0.05, label="Threshold")
+                    t_btn = gr.Button("Redact", variant="primary")
+                with gr.Column():
+                    t_out = gr.Textbox(label="Redacted (safe to send downstream)", lines=10)
+                    t_sum = gr.Markdown()
+                    t_tab = gr.Dataframe(
+                        headers=["type", "value", "score", "source"],
+                        label="Detected PII", wrap=True,
+                    )
+                    with gr.Accordion("Rehydrate (local only)", open=False):
+                        t_reh_btn = gr.Button("Restore original values")
+                        t_reh = gr.Textbox(label="Rehydrated", lines=6)
+
+            t_btn.click(run_text, [t_in, t_labels, t_thr], [t_out, t_tab, t_sum, t_map])
+            t_reh_btn.click(do_rehydrate, [t_out, t_map], [t_reh])
+
+        # --- Image tab -------------------------------------------------------
+        with gr.Tab("Image"):
+            gr.Markdown(
+                "Upload a document or ID image. A local vision model "
+                "(MiniCPM-V-4.6) extracts the fields, then Redac redacts them."
             )
-            run_btn = gr.Button("Redact", variant="primary")
-        with gr.Column():
-            out = gr.Textbox(label="Redacted (safe to send downstream)", lines=10)
-            summary = gr.Markdown()
-            entities = gr.Dataframe(
-                headers=["type", "value", "score", "source"],
-                label="Detected PII",
-                wrap=True,
+            i_map = gr.State({})
+            with gr.Row():
+                with gr.Column():
+                    i_in = gr.Image(label="Document / ID image", type="pil")
+                    i_labels = gr.Dropdown(
+                        label="PII types", choices=DEFAULT_LABELS,
+                        value=DEFAULT_LABELS, multiselect=True,
+                    )
+                    i_thr = gr.Slider(0.1, 0.9, value=0.45, step=0.05, label="Threshold")
+                    i_btn = gr.Button("Extract & redact", variant="primary")
+                with gr.Column():
+                    i_extracted = gr.Textbox(label="Extracted fields (raw)", lines=8)
+                    i_out = gr.Textbox(label="Redacted (safe to send downstream)", lines=8)
+                    i_sum = gr.Markdown()
+                    i_tab = gr.Dataframe(
+                        headers=["type", "value", "score", "source"],
+                        label="Detected PII", wrap=True,
+                    )
+                    with gr.Accordion("Rehydrate (local only)", open=False):
+                        i_reh_btn = gr.Button("Restore original values")
+                        i_reh = gr.Textbox(label="Rehydrated", lines=6)
+
+            i_btn.click(
+                run_image, [i_in, i_labels, i_thr],
+                [i_extracted, i_out, i_tab, i_sum, i_map],
             )
-            with gr.Accordion("Rehydrate (local only)", open=False):
-                rehydrate_btn = gr.Button("Restore original values")
-                restored = gr.Textbox(label="Rehydrated", lines=6)
-
-    run_btn.click(
-        run_redaction,
-        inputs=[inp, labels, threshold],
-        outputs=[out, entities, summary, mapping_state],
-    )
-    rehydrate_btn.click(
-        do_rehydrate, inputs=[out, mapping_state], outputs=[restored]
-    )
+            i_reh_btn.click(do_rehydrate, [i_out, i_map], [i_reh])
 
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    demo.launch(server_name="0.0.0.0", server_port=7860, theme=gr.themes.Soft())

redac/__init__.py

@@ -3,6 +3,7 @@ confidential text reaches a downstream model. Reversible by design."""
 
 from .detect import Entity, detect_entities, DEFAULT_LABELS
 from .redact import redact, rehydrate
+from .vision import extract_text_from_image
 
 __all__ = [
     "Entity",
@@ -10,4 +11,5 @@ __all__ = [
     "DEFAULT_LABELS",
     "redact",
     "rehydrate",
+    "extract_text_from_image",
 ]

redac/detect.py

@@ -58,6 +58,12 @@ _REGEX_RECOGNIZERS = [
 ]
 
 
+# Common date shapes the greedy phone pattern would otherwise swallow.
+_DATE_RE = re.compile(
+    r"^\d{4}[./-]\d{1,2}[./-]\d{1,2}$|^\d{1,2}[./-]\d{1,2}[./-]\d{2,4}$"
+)
+
+
 def _regex_entities(text: str) -> List[Entity]:
     out: List[Entity] = []
     for label, pattern in _REGEX_RECOGNIZERS:
@@ -65,6 +71,9 @@ def _regex_entities(text: str) -> List[Entity]:
             span = m.group().strip()
             if len(span) < 4:
                 continue
+            # Don't let the phone recognizer misfire on dates.
+            if label == "phone number" and _DATE_RE.match(span):
+                continue
             out.append(
                 Entity(
                     start=m.start(),

redac/vision.py

@@ -0,0 +1,82 @@
+"""Image -> text extraction with a local vision model (MiniCPM-V-4.6).
+
+Runs in-Space on ZeroGPU via the @spaces.GPU decorator. The model reads a
+document/ID image and returns the fields as plain text, which then flows
+through the same PII detection + redaction core as typed text.
+
+Local dev: set REDAC_MOCK=1 to skip the model entirely and return a canned
+extraction, so the Gradio UI runs on a laptop with no GPU.
+"""
+
+from __future__ import annotations
+
+import os
+from functools import lru_cache
+
+MODEL_ID = "openbmb/MiniCPM-V-4.6"
+
+EXTRACTION_PROMPT = (
+    "You are a document data extractor. Read this image and transcribe ALL "
+    "personal and sensitive information you can find. Output one field per "
+    "line as 'field: value'. Include, when present: full name, date of birth, "
+    "address, passport/ID/driver-license number, national ID or social "
+    "security number, phone, email, and any account or card numbers. "
+    "Transcribe values exactly as written. Do not invent fields."
+)
+
+_MOCK_EXTRACTION = (
+    "full name: John A. Doe\n"
+    "date of birth: 1985-04-12\n"
+    "address: 221B Baker Street, London\n"
+    "passport number: X1234567\n"
+    "national id number: 123-45-6789\n"
+    "email: john.doe@example.com\n"
+    "phone: +49 151 23456789"
+)
+
+
+def _is_mock() -> bool:
+    return os.environ.get("REDAC_MOCK", "").strip() in {"1", "true", "True"}
+
+
+# ZeroGPU decorator; degrade to a no-op decorator when `spaces` is absent
+# (local dev) so the module imports cleanly off-Space.
+try:
+    import spaces  # type: ignore
+
+    _gpu = spaces.GPU(duration=120)
+except Exception:  # pragma: no cover - local fallback
+    def _gpu(fn):
+        return fn
+
+
+@lru_cache(maxsize=1)
+def _load_model():
+    import torch
+    from transformers import AutoModel, AutoTokenizer
+
+    model = AutoModel.from_pretrained(
+        MODEL_ID,
+        trust_remote_code=True,
+        attn_implementation="sdpa",
+        torch_dtype=torch.bfloat16,
+    ).eval()
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, trust_remote_code=True)
+    return model, tokenizer
+
+
+@_gpu
+def _chat(image, prompt: str) -> str:
+    model, tokenizer = _load_model()
+    model = model.to("cuda")
+    msgs = [{"role": "user", "content": [image, prompt]}]
+    return model.chat(image=None, msgs=msgs, tokenizer=tokenizer)
+
+
+def extract_text_from_image(image, prompt: str | None = None) -> str:
+    """Return extracted field text from a PIL image. Honors REDAC_MOCK."""
+    if image is None:
+        return ""
+    if _is_mock():
+        return _MOCK_EXTRACTION
+    return _chat(image.convert("RGB"), prompt or EXTRACTION_PROMPT).strip()

requirements.txt

@@ -1,4 +1,10 @@
 gradio==6.18.0
 gliner>=0.2.13
 torch
+torchvision
+transformers>=4.44
+accelerate
+sentencepiece
+pillow
 huggingface_hub
+spaces