Track image and font assets with Git LFS so Hugging Face Spaces accepts the push.

.gitattributes

@@ -33,3 +33,10 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+*.ico filter=lfs diff=lfs merge=lfs -text
+*.woff filter=lfs diff=lfs merge=lfs -text
+*.woff2 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,6 @@
+references/
+.cursor/
+.git/cursor/
+frontend/node_modules/
+**/__pycache__/
+*.pyc

README.md

@@ -1,15 +1,84 @@
 ---
-title: Ocr Ebola
-emoji: 🏢
+title: OCR Capacity Building as a Service
+emoji: 🏥
 colorFrom: blue
-colorTo: blue
+colorTo: green
 sdk: gradio
 sdk_version: 6.20.0
-python_version: '3.12'
+python_version: "3.12.12"
 app_file: app.py
 pinned: false
 license: mit
-short_description: open api for ebola contact tracing in `DRCongo`
+hardware: zero-gpu
+startup_duration_timeout: 30m
+models:
+  - ATH-MaaS/OvisOCR2
+  - zai-org/GLM-OCR
+preload_from_hub:
+  - ATH-MaaS/OvisOCR2
+  - zai-org/GLM-OCR
+short_description: Open OCR API for Ebola contact-tracing docs in DRC (OvisOCR2 + GLM-OCR).
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# OCR Capacity Building as a Service
+
+Open OCR API for Ebola contact-tracing documents in the DRC. Choose between
+[ATH-MaaS/OvisOCR2](https://huggingface.co/ATH-MaaS/OvisOCR2) and
+[zai-org/GLM-OCR](https://huggingface.co/zai-org/GLM-OCR), upload a page image or
+multi-page PDF, and stream Markdown (with LaTeX formulas and HTML tables).
+
+**OvisOCR2** emits figure placeholders that this Space materializes as cropped
+visual regions. **GLM-OCR** returns text recognition output without bbox crops.
+
+## Supported inputs
+
+- Images: PNG, JPEG, WebP
+- PDFs: up to 50 pages (rasterized locally; up to 4 pages per ZeroGPU lease)
+
+## API
+
+Streaming endpoint: `/run_ocr`
+
+| Arg | Type | Default | Description |
+|-----|------|---------|-------------|
+| `image_path` | FileData | required | Uploaded image or PDF |
+| `page_index` | int | `0` | 0-based start page for this lease |
+| `page_count` | int | `4` | Max pages in this GPU batch |
+| `model_choice` | str | `"OvisOCR2"` | `"OvisOCR2"` or `"GLM-OCR"` |
+| `prompt` | str | `""` | Override; empty → model default |
+
+```python
+from gradio_client import Client, handle_file
+
+client = Client("OWNER/ocr-ebola")
+job = client.submit(
+    handle_file("form.pdf"),
+    0,
+    4,
+    "OvisOCR2",
+    "",
+    api_name="/run_ocr",
+)
+for chunk in job:
+    print(chunk["event"], chunk.get("current_page"), chunk.get("char_count"))
+```
+
+Also available as an MCP tool named `run_ocr`. Health check: `GET /healthz`.
+
+## Local run
+
+```bash
+# Backend deps (Space installs requirements.txt automatically)
+pip install -r requirements.txt
+
+# Frontend (build once; commit dist/ for Spaces)
+cd frontend && npm install && npm run build && cd ..
+
+# Mock stream without loading weights (Windows PowerShell: $env:OCR_TEST_MODE=1)
+OCR_TEST_MODE=1 python app.py
+
+# Real models (needs CUDA)
+python app.py
+```
+
+Open `http://127.0.0.1:7860`.

app.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+import mimetypes
+import os
+from collections.abc import Iterator
+from typing import Any
+from urllib.parse import urlsplit
+
+os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+
+from backend.spaces_shim import spaces  # noqa: E402  (must precede torch)
+
+import gradio as gr  # noqa: E402
+from fastapi import HTTPException  # noqa: E402
+from fastapi.middleware.cors import CORSMiddleware  # noqa: E402
+from fastapi.responses import FileResponse, JSONResponse, Response  # noqa: E402
+from gradio.data_classes import FileData  # noqa: E402
+from starlette.staticfiles import StaticFiles  # noqa: E402
+
+from backend.config import (  # noqa: E402
+    DIST_DIR,
+    GPU_DURATION_CEILING,
+    GPU_DURATION_FLOOR,
+    GPU_SECONDS_PER_PAGE,
+    MAX_PDF_PAGES,
+    MODEL_GLM,
+    MODEL_OVIS,
+    PAGES_PER_GPU_REQUEST,
+    TEST_MODE,
+)
+from backend.documents import document_info  # noqa: E402
+from backend.load_models import load_models, models_loaded  # noqa: E402
+from backend.orchestrator import _file_path, run_ocr_batch  # noqa: E402
+
+
+def server_config() -> tuple[int, str | None, str | None]:
+    port = int(os.getenv("PORT", os.getenv("GRADIO_SERVER_PORT", "7860")))
+    configured_root = (
+        os.getenv("OCR_ROOT_PATH", "").strip() or os.getenv("GRADIO_ROOT_PATH", "").strip()
+    )
+    public_url = None
+    root_path = None
+    if configured_root.startswith(("http://", "https://")):
+        public_url = configured_root
+        path = urlsplit(configured_root).path.rstrip("/")
+        root_path = path or None
+    elif configured_root:
+        root_path = configured_root.rstrip("/") or None
+    return port, root_path, public_url
+
+
+SERVER_PORT, ROOT_PATH, PUBLIC_URL = server_config()
+
+
+class CachedStaticFiles(StaticFiles):
+    """Serve immutable production assets from the browser cache after first load."""
+
+    async def get_response(self, path: str, scope: dict[str, Any]) -> Any:
+        response = await super().get_response(path, scope)
+        if response.status_code == 200:
+            response.headers["Cache-Control"] = "public, max-age=31536000, immutable"
+        return response
+
+
+EXAMPLE_ASSETS = (
+    {
+        path.name: (
+            path.read_bytes(),
+            mimetypes.guess_type(path.name)[0] or "application/octet-stream",
+        )
+        for path in (DIST_DIR / "examples").iterdir()
+        if path.is_file()
+    }
+    if (DIST_DIR / "examples").is_dir()
+    else {}
+)
+
+load_models()
+
+app = gr.Server()
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://127.0.0.1:4173", "http://localhost:4173"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+def _gpu_duration(
+    image_path: FileData | dict[str, Any],
+    page_index: int = 0,
+    page_count: int = PAGES_PER_GPU_REQUEST,
+    model_choice: str = "OvisOCR2",
+    prompt: str = "",
+) -> int:
+    del model_choice, prompt
+    configured_duration = os.getenv("OCR_GPU_DURATION", "").strip()
+    if configured_duration:
+        return int(configured_duration)
+
+    requested_count = max(1, min(PAGES_PER_GPU_REQUEST, int(page_count)))
+    try:
+        path = _file_path(image_path)
+        _, total_pages = document_info(path)
+        remaining_pages = max(1, total_pages - int(page_index))
+        requested_count = min(requested_count, remaining_pages)
+    except Exception:
+        pass
+
+    return max(
+        GPU_DURATION_FLOOR,
+        min(GPU_DURATION_CEILING, requested_count * GPU_SECONDS_PER_PAGE),
+    )
+
+
+@spaces.GPU(duration=_gpu_duration)
+def _run_ocr_gpu(
+    image_path: FileData,
+    page_index: int = 0,
+    page_count: int = PAGES_PER_GPU_REQUEST,
+    model_choice: str = "OvisOCR2",
+    prompt: str = "",
+) -> Iterator[dict[str, Any]]:
+    yield from run_ocr_batch(
+        image_path,
+        page_index=page_index,
+        page_count=page_count,
+        model_choice=model_choice,
+        prompt=prompt,
+    )
+
+
+@app.api(name="run_ocr", concurrency_limit=1, time_limit=300)
+@app.mcp.tool(name="run_ocr")
+def run_ocr(
+    image_path: FileData,
+    page_index: int = 0,
+    page_count: int = PAGES_PER_GPU_REQUEST,
+    model_choice: str = "OvisOCR2",
+    prompt: str = "",
+) -> Iterator[dict[str, Any]]:
+    """Stream OCR Markdown for a bounded batch of document pages."""
+    yield from _run_ocr_gpu(
+        image_path,
+        page_index=page_index,
+        page_count=page_count,
+        model_choice=model_choice,
+        prompt=prompt,
+    )
+
+
+@app.get("/healthz")
+def healthz() -> JSONResponse:
+    loaded = models_loaded()
+    return JSONResponse(
+        {
+            "status": "ok",
+            "models": {
+                "OvisOCR2": MODEL_OVIS,
+                "GLM-OCR": MODEL_GLM,
+            },
+            "loaded": loaded,
+            "backend": "mock" if TEST_MODE else "transformers",
+            "max_pdf_pages": MAX_PDF_PAGES,
+            "pages_per_gpu_request": PAGES_PER_GPU_REQUEST,
+            "gpu_seconds_per_page": GPU_SECONDS_PER_PAGE,
+            "gpu_duration_floor": GPU_DURATION_FLOOR,
+            "gpu_duration_ceiling": GPU_DURATION_CEILING,
+            "root_path": ROOT_PATH,
+            "public_url": PUBLIC_URL,
+        }
+    )
+
+
+@app.get("/examples/{filename}")
+def example_asset(filename: str) -> Response:
+    asset = EXAMPLE_ASSETS.get(filename)
+    if asset is None:
+        raise HTTPException(status_code=404, detail="Example not found")
+    content, media_type = asset
+    return Response(
+        content=content,
+        media_type=media_type,
+        headers={"Cache-Control": "public, max-age=31536000, immutable"},
+    )
+
+
+if DIST_DIR.is_dir():
+    for route, directory in (
+        ("/assets", DIST_DIR / "assets"),
+        ("/brand", DIST_DIR / "brand"),
+        ("/vendor", DIST_DIR / "vendor"),
+    ):
+        if directory.is_dir():
+            app.mount(
+                route,
+                CachedStaticFiles(directory=directory),
+                name=route.strip("/").replace("/", "-"),
+            )
+
+
+@app.get("/")
+def homepage() -> FileResponse:
+    index_path = DIST_DIR / "index.html"
+    if not index_path.is_file():
+        raise RuntimeError(
+            "Frontend build missing. Run `cd frontend && npm ci && npm run build` "
+            "before launching app.py."
+        )
+    return FileResponse(index_path, headers={"Cache-Control": "no-cache"})
+
+
+@app.get("/favicon.ico")
+def favicon() -> FileResponse:
+    favicon_path = DIST_DIR / "favicon.ico"
+    if not favicon_path.is_file():
+        raise HTTPException(status_code=404, detail="Favicon not found")
+    return FileResponse(
+        favicon_path,
+        headers={"Cache-Control": "public, max-age=31536000, immutable"},
+    )
+
+
+if __name__ == "__main__":
+    app.launch(
+        server_name=os.getenv("GRADIO_SERVER_NAME", "0.0.0.0"),
+        server_port=SERVER_PORT,
+        root_path=ROOT_PATH,
+        show_error=True,
+    )

backend/__init__.py

@@ -0,0 +1 @@
+"""OCR Capacity Building backend package."""

backend/adapters/__init__.py

@@ -0,0 +1 @@
+"""Model-specific streaming OCR adapters."""

backend/adapters/glm.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import os
+import tempfile
+import threading
+import time
+from collections.abc import Iterator
+
+import torch
+from PIL import Image, ImageOps
+
+from backend.bbox import clean_truncated_repeats
+from backend.config import (
+    MAX_NEW_TOKENS,
+    MOCK_MARKDOWN,
+    STREAM_MAX_INTERVAL,
+    STREAM_MIN_CHARS,
+    TEST_MODE,
+)
+from backend import load_models
+
+
+def infer_stream(page_image: Image.Image, prompt: str) -> Iterator[str]:
+    if TEST_MODE:
+        # GLM path: no bbox tags in mock
+        mock = MOCK_MARKDOWN.replace(
+            '<img src="images/bbox_120_130_880_420.jpg" />',
+            "(figure omitted)",
+        )
+        for end in range(64, len(mock) + 64, 64):
+            yield mock[:end]
+        return
+
+    processor = load_models.glm_processor
+    model = load_models.glm_model
+    if processor is None or model is None:
+        raise RuntimeError("GLM-OCR is not loaded.")
+
+    from transformers import TextIteratorStreamer
+
+    if page_image.mode in ("RGBA", "LA", "P"):
+        page_image = page_image.convert("RGB")
+    page_image = ImageOps.exif_transpose(page_image)
+
+    tmp_path: str | None = None
+    try:
+        tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
+        page_image.save(tmp.name, "PNG")
+        tmp_path = tmp.name
+        tmp.close()
+
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "url": tmp_path},
+                    {"type": "text", "text": prompt},
+                ],
+            }
+        ]
+        inputs = processor.apply_chat_template(
+            messages,
+            tokenize=True,
+            add_generation_prompt=True,
+            return_dict=True,
+            return_tensors="pt",
+        )
+        inputs.pop("token_type_ids", None)
+        inputs = {
+            key: value.to(model.device) if hasattr(value, "to") else value
+            for key, value in inputs.items()
+        }
+
+        streamer = TextIteratorStreamer(
+            processor.tokenizer if hasattr(processor, "tokenizer") else processor,
+            skip_prompt=True,
+            skip_special_tokens=True,
+        )
+        errors: list[BaseException] = []
+
+        def generate() -> None:
+            try:
+                with torch.inference_mode():
+                    model.generate(
+                        **inputs,
+                        streamer=streamer,
+                        max_new_tokens=MAX_NEW_TOKENS,
+                    )
+            except BaseException as error:
+                errors.append(error)
+                try:
+                    streamer.end()
+                except Exception:
+                    pass
+
+        worker = threading.Thread(target=generate, name="glm-ocr-generate", daemon=True)
+        worker.start()
+        text = ""
+        last_yielded = ""
+        last_yield_time = time.monotonic()
+        for fragment in streamer:
+            text += fragment
+            now = time.monotonic()
+            if (
+                len(text) - len(last_yielded) >= STREAM_MIN_CHARS
+                or now - last_yield_time >= STREAM_MAX_INTERVAL
+            ):
+                yield text
+                last_yielded = text
+                last_yield_time = now
+
+        worker.join()
+        if errors:
+            raise RuntimeError("GLM-OCR generation failed.") from errors[0]
+        final_text = clean_truncated_repeats(text.strip())
+        if final_text and final_text != last_yielded:
+            yield final_text
+    finally:
+        if tmp_path and os.path.exists(tmp_path):
+            try:
+                os.unlink(tmp_path)
+            except OSError:
+                pass

backend/adapters/ovis.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import threading
+import time
+from collections.abc import Iterator
+from typing import Any
+
+import torch
+from PIL import Image
+
+from backend.bbox import clean_truncated_repeats
+from backend.config import (
+    MAX_NEW_TOKENS,
+    MOCK_MARKDOWN,
+    STREAM_MAX_INTERVAL,
+    STREAM_MIN_CHARS,
+    TEST_MODE,
+)
+from backend import load_models
+
+
+def generation_token_ids(processor: Any) -> dict[str, int]:
+    tokenizer = processor.tokenizer
+    return {
+        "eos_token_id": int(tokenizer.eos_token_id),
+        "pad_token_id": int(tokenizer.pad_token_id),
+    }
+
+
+def infer_stream(page_image: Image.Image, prompt: str) -> Iterator[str]:
+    if TEST_MODE:
+        for end in range(64, len(MOCK_MARKDOWN) + 64, 64):
+            yield MOCK_MARKDOWN[:end]
+        return
+
+    processor = load_models.ovis_processor
+    model = load_models.ovis_model
+    if processor is None or model is None:
+        raise RuntimeError("OvisOCR2 is not loaded.")
+
+    from transformers import TextIteratorStreamer
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": page_image},
+                {"type": "text", "text": prompt},
+            ],
+        }
+    ]
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt",
+        enable_thinking=False,
+    ).to(model.device)
+
+    streamer = TextIteratorStreamer(
+        processor.tokenizer,
+        skip_prompt=True,
+        skip_special_tokens=True,
+        clean_up_tokenization_spaces=False,
+    )
+    errors: list[BaseException] = []
+
+    def generate() -> None:
+        try:
+            with torch.inference_mode():
+                model.generate(
+                    **inputs,
+                    streamer=streamer,
+                    max_new_tokens=MAX_NEW_TOKENS,
+                    do_sample=False,
+                    temperature=None,
+                    top_p=None,
+                    top_k=None,
+                    **generation_token_ids(processor),
+                )
+        except BaseException as error:
+            errors.append(error)
+            streamer.on_finalized_text("", stream_end=True)
+
+    worker = threading.Thread(target=generate, name="ovisocr2-generate", daemon=True)
+    worker.start()
+    text = ""
+    last_yielded = ""
+    last_yield_time = time.monotonic()
+    for fragment in streamer:
+        text += fragment
+        now = time.monotonic()
+        if (
+            len(text) - len(last_yielded) >= STREAM_MIN_CHARS
+            or now - last_yield_time >= STREAM_MAX_INTERVAL
+        ):
+            yield text
+            last_yielded = text
+            last_yield_time = now
+
+    worker.join()
+    if errors:
+        raise RuntimeError("OvisOCR2 generation failed.") from errors[0]
+    final_text = clean_truncated_repeats(text.strip())
+    if final_text and final_text != last_yielded:
+        yield final_text

backend/bbox.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import base64
+import html
+import io
+import re
+
+from PIL import Image
+
+BBOX_IMAGE_PATTERN = re.compile(
+    r'<img\s+src=["\']images/bbox_(\d+)_(\d+)_(\d+)_(\d+)\.jpg["\']\s*/?>',
+    flags=re.IGNORECASE,
+)
+
+UNMATERIALIZED_BBOX_IMAGE_PATTERN = re.compile(
+    r'<img\b[^>]*\bsrc=["\']images/bbox_[^"\']+["\'][^>]*>',
+    flags=re.IGNORECASE,
+)
+
+
+def clean_truncated_repeats(
+    text: str,
+    min_text_len: int = 8000,
+    max_period: int = 200,
+    min_period: int = 1,
+    min_repeat_chars: int = 100,
+    min_repeat_times: int = 5,
+) -> str:
+    """Remove a repeated suffix created when generation reaches its token ceiling."""
+    n = len(text)
+    if n < min_text_len:
+        return text
+
+    max_period = min(max_period, n - 1)
+    for unit_len in range(min_period, max_period + 1):
+        if text[n - 1] != text[n - 1 - unit_len]:
+            continue
+        match_len = 1
+        idx = n - 2
+        while idx >= unit_len and text[idx] == text[idx - unit_len]:
+            match_len += 1
+            idx -= 1
+        total_len = match_len + unit_len
+        repeat_times = total_len // unit_len
+        tail_len = total_len % unit_len
+        if repeat_times >= min_repeat_times and total_len >= min_repeat_chars:
+            return text[: n - total_len + unit_len] + text[n - tail_len :]
+    return text
+
+
+def neutralize_unmaterialized_bbox_images(markdown: str) -> str:
+    """Render placeholder examples as code instead of issuing broken requests."""
+
+    def replace(match: re.Match[str]) -> str:
+        escaped = html.escape(match.group(0), quote=False)
+        return f'<code class="unresolved-image-reference">{escaped}</code>'
+
+    return UNMATERIALIZED_BBOX_IMAGE_PATTERN.sub(replace, markdown)
+
+
+def stream_safe_markdown(markdown: str) -> str:
+    """Avoid broken image requests until a page's bbox crops are materialized."""
+    return neutralize_unmaterialized_bbox_images(
+        BBOX_IMAGE_PATTERN.sub(
+            '<div class="visual-placeholder">Preparing visual region…</div>',
+            markdown,
+        )
+    )
+
+
+def materialize_bbox_images(markdown: str, page_image: Image.Image) -> str:
+    """Replace bbox image placeholders in rendered output with safe data-URI crops."""
+    width, height = page_image.size
+
+    def replace(match: re.Match[str]) -> str:
+        left, top, right, bottom = (int(value) for value in match.groups())
+        x1 = max(0, min(width, round(left * width / 1000)))
+        y1 = max(0, min(height, round(top * height / 1000)))
+        x2 = max(0, min(width, round(right * width / 1000)))
+        y2 = max(0, min(height, round(bottom * height / 1000)))
+        if x2 <= x1 or y2 <= y1:
+            return match.group(0)
+
+        crop = page_image.crop((x1, y1, x2, y2)).convert("RGB")
+        crop.thumbnail((1200, 1200), Image.Resampling.BILINEAR)
+        buffer = io.BytesIO()
+        crop.save(buffer, format="JPEG", quality=85, optimize=False)
+        payload = base64.b64encode(buffer.getvalue()).decode("ascii")
+        return (
+            f'<img src="data:image/jpeg;base64,{payload}" alt="Visual region" '
+            'loading="lazy" decoding="async" />'
+        )
+
+    return neutralize_unmaterialized_bbox_images(BBOX_IMAGE_PATTERN.sub(replace, markdown))

backend/config.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Literal
+
+BASE_DIR = Path(__file__).resolve().parent.parent
+DIST_DIR = BASE_DIR / "dist"
+
+ModelChoice = Literal["OvisOCR2", "GLM-OCR"]
+
+MODEL_OVIS = "ATH-MaaS/OvisOCR2"
+MODEL_GLM = "zai-org/GLM-OCR"
+
+TEST_MODE = os.getenv("OCR_TEST_MODE", os.getenv("OVISOCR_TEST_MODE", "0")).lower() in {
+    "1",
+    "true",
+    "yes",
+}
+
+MAX_NEW_TOKENS = int(os.getenv("OCR_MAX_NEW_TOKENS", "16384"))
+MAX_PDF_PAGES = int(os.getenv("OCR_MAX_PDF_PAGES", "50"))
+PAGES_PER_GPU_REQUEST = max(1, min(5, int(os.getenv("OCR_PAGES_PER_GPU_REQUEST", "4"))))
+GPU_SECONDS_PER_PAGE = max(15, int(os.getenv("OCR_GPU_SECONDS_PER_PAGE", "30")))
+GPU_DURATION_FLOOR = max(15, int(os.getenv("OCR_GPU_DURATION_FLOOR", "45")))
+GPU_DURATION_CEILING = max(
+    GPU_DURATION_FLOOR,
+    int(os.getenv("OCR_GPU_DURATION_CEILING", "120")),
+)
+PDF_RENDER_SCALE = float(os.getenv("OCR_PDF_RENDER_SCALE", "2.0"))
+STREAM_MIN_CHARS = int(os.getenv("OCR_STREAM_MIN_CHARS", "64"))
+STREAM_MAX_INTERVAL = float(os.getenv("OCR_STREAM_MAX_INTERVAL", "0.25"))
+MIN_PIXELS = 448 * 448
+MAX_PIXELS = 2880 * 2880
+
+OVIS_OCR_PROMPT = (
+    "\nExtract all readable content from the image in natural human reading order "
+    "and output the result as a single Markdown document. For charts or images, "
+    'represent them using an HTML image tag: <img src="images/bbox_{left}_{top}_{right}_{bottom}.jpg" />, '
+    "where left, top, right, bottom are bounding box coordinates scaled to [0, 1000). "
+    "Format formulas as LaTeX. Format tables as HTML: <table>...</table>. "
+    "Transcribe all other text as standard Markdown. Preserve the original text "
+    "without translation or paraphrasing."
+)
+
+GLM_DEFAULT_PROMPT = "Text Recognition:"
+GLM_TASK_PROMPTS = {
+    "Text": "Text Recognition:",
+    "Formula": "Formula Recognition:",
+    "Table": "Table Recognition:",
+}
+
+MOCK_MARKDOWN = r"""# Contact tracing — sample page
+
+| Field | Value |
+|-------|-------|
+| Case ID | EVD-2024-0042 |
+| Nom | Mbuyi, Jean |
+| Contact | +243 81 000 0000 |
+| Localité | Beni, Nord-Kivu |
+
+## Notes
+
+Fever onset $t_0$ reported 3 days prior to interview.
+
+\[
+R_t = \frac{C_{t}}{C_{t-1}}
+\]
+
+<img src="images/bbox_120_130_880_420.jpg" />
+
+Source: field form (mock)."""
+
+
+def default_prompt(model_choice: ModelChoice) -> str:
+    if model_choice == "OvisOCR2":
+        return OVIS_OCR_PROMPT
+    if model_choice == "GLM-OCR":
+        return GLM_DEFAULT_PROMPT
+    raise ValueError(f"Unknown model_choice: {model_choice}")
+
+
+def resolve_prompt(model_choice: ModelChoice, prompt: str) -> str:
+    text = (prompt or "").strip()
+    if not text:
+        return default_prompt(model_choice)
+    if model_choice == "GLM-OCR" and text in GLM_TASK_PROMPTS:
+        return GLM_TASK_PROMPTS[text]
+    return text
+
+
+def hub_id_for(model_choice: ModelChoice) -> str:
+    if model_choice == "OvisOCR2":
+        return MODEL_OVIS
+    if model_choice == "GLM-OCR":
+        return MODEL_GLM
+    raise ValueError(f"Unknown model_choice: {model_choice}")

backend/documents.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import base64
+import io
+from pathlib import Path
+
+import fitz
+from PIL import Image, ImageOps
+
+from backend.config import MAX_PDF_PAGES, PDF_RENDER_SCALE
+
+
+def document_info(path: str) -> tuple[str, int]:
+    suffix = Path(path).suffix.lower()
+    try:
+        with Path(path).open("rb") as file:
+            header = file.read(5)
+    except OSError as error:
+        raise ValueError("The uploaded document could not be read.") from error
+
+    if suffix == ".pdf" or header == b"%PDF-":
+        with fitz.open(path) as document:
+            total_pages = document.page_count
+        if total_pages < 1:
+            raise ValueError("The uploaded PDF has no pages.")
+        if total_pages > MAX_PDF_PAGES:
+            raise ValueError(
+                f"This demo accepts up to {MAX_PDF_PAGES} PDF pages; received {total_pages}."
+            )
+        return "pdf", total_pages
+
+    try:
+        with Image.open(path) as source:
+            source.verify()
+    except Exception as error:
+        raise ValueError("Please upload a valid PNG, JPEG, WebP, or PDF file.") from error
+    return "image", 1
+
+
+def load_document_page(path: str, document_type: str, page_index: int) -> Image.Image:
+    if document_type == "pdf":
+        with fitz.open(path) as document:
+            page = document.load_page(page_index)
+            pixmap = page.get_pixmap(
+                matrix=fitz.Matrix(PDF_RENDER_SCALE, PDF_RENDER_SCALE),
+                colorspace=fitz.csRGB,
+                alpha=False,
+            )
+        return Image.frombytes("RGB", (pixmap.width, pixmap.height), pixmap.samples)
+
+    with Image.open(path) as source:
+        return ImageOps.exif_transpose(source).convert("RGB")
+
+
+def page_preview_data_uri(page_image: Image.Image) -> str:
+    preview = page_image.copy().convert("RGB")
+    preview.thumbnail((1400, 1800), Image.Resampling.BILINEAR)
+    buffer = io.BytesIO()
+    preview.save(buffer, format="JPEG", quality=82, optimize=False)
+    payload = base64.b64encode(buffer.getvalue()).decode("ascii")
+    return f"data:image/jpeg;base64,{payload}"

backend/load_models.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from typing import Any
+
+import torch
+
+from backend.config import (
+    MAX_PIXELS,
+    MIN_PIXELS,
+    MODEL_GLM,
+    MODEL_OVIS,
+    TEST_MODE,
+)
+
+ovis_processor: Any = None
+ovis_model: Any = None
+glm_processor: Any = None
+glm_model: Any = None
+
+
+def load_models() -> None:
+    """Eager-load both OCR models onto CUDA (ZeroGPU contract)."""
+    global ovis_processor, ovis_model, glm_processor, glm_model
+    if TEST_MODE:
+        return
+
+    from transformers import (
+        AutoModelForImageTextToText,
+        AutoProcessor,
+        Qwen3_5ForConditionalGeneration,
+    )
+
+    ovis_processor = AutoProcessor.from_pretrained(
+        MODEL_OVIS,
+        min_pixels=MIN_PIXELS,
+        max_pixels=MAX_PIXELS,
+    )
+    ovis_model = Qwen3_5ForConditionalGeneration.from_pretrained(
+        MODEL_OVIS,
+        dtype=torch.bfloat16,
+        attn_implementation="sdpa",
+    ).to("cuda")
+    ovis_model.eval()
+
+    glm_processor = AutoProcessor.from_pretrained(MODEL_GLM, trust_remote_code=True)
+    glm_model = AutoModelForImageTextToText.from_pretrained(
+        MODEL_GLM,
+        torch_dtype=torch.bfloat16,
+        trust_remote_code=True,
+    ).to("cuda")
+    glm_model.eval()
+
+
+def models_loaded() -> dict[str, bool]:
+    if TEST_MODE:
+        return {"ovis": True, "glm": True, "test_mode": True}
+    return {
+        "ovis": ovis_processor is not None and ovis_model is not None,
+        "glm": glm_processor is not None and glm_model is not None,
+        "test_mode": False,
+    }

backend/orchestrator.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import time
+from collections.abc import Iterator
+from typing import Any
+
+from typing import assert_never
+
+from gradio.data_classes import FileData
+
+from backend.adapters import glm as glm_adapter
+from backend.adapters import ovis as ovis_adapter
+from backend.bbox import clean_truncated_repeats, materialize_bbox_images, stream_safe_markdown
+from backend.config import (
+    PAGES_PER_GPU_REQUEST,
+    TEST_MODE,
+    ModelChoice,
+    resolve_prompt,
+)
+from backend.documents import document_info, load_document_page, page_preview_data_uri
+from backend.stream_protocol import stream_payload
+
+
+def _file_path(file_data: FileData | dict[str, Any]) -> str:
+    if isinstance(file_data, dict):
+        path = file_data.get("path")
+    else:
+        path = getattr(file_data, "path", None)
+    if not path:
+        raise ValueError("No uploaded document was provided.")
+    return str(path)
+
+
+def run_ocr_batch(
+    image_path: FileData | dict[str, Any],
+    page_index: int = 0,
+    page_count: int = PAGES_PER_GPU_REQUEST,
+    model_choice: str = "OvisOCR2",
+    prompt: str = "",
+) -> Iterator[dict[str, Any]]:
+    """Stream a bounded group of pages within one ZeroGPU reservation."""
+    started = time.perf_counter()
+    choice: ModelChoice
+    if model_choice == "OvisOCR2":
+        choice = "OvisOCR2"
+    elif model_choice == "GLM-OCR":
+        choice = "GLM-OCR"
+    else:
+        raise ValueError(f"Unsupported model_choice: {model_choice}")
+
+    path = _file_path(image_path)
+    document_type, total_pages = document_info(path)
+    page_index = int(page_index)
+    if page_index < 0 or page_index >= total_pages:
+        raise ValueError(
+            f"Requested PDF page {page_index + 1}, but this document has {total_pages} pages."
+        )
+
+    requested_count = max(1, min(PAGES_PER_GPU_REQUEST, int(page_count)))
+    batch_end_index = min(total_pages, page_index + requested_count)
+    batch_start_page = page_index + 1
+    batch_end_page = batch_end_index
+    completed_pages: list[dict[str, Any]] = []
+    active_prompt = resolve_prompt(choice, prompt)
+    backend_name = "mock" if TEST_MODE else "transformers"
+
+    print(
+        f"[ocr] {choice} batch start pages {batch_start_page}-{batch_end_page}/{total_pages}",
+        flush=True,
+    )
+
+    for current_index in range(page_index, batch_end_index):
+        page_number = current_index + 1
+        page_image = load_document_page(path, document_type, current_index)
+        page_started = time.perf_counter()
+        current = {
+            "page_number": page_number,
+            "markdown": "",
+            "render_markdown": "",
+            "status": "streaming",
+            "elapsed_seconds": 0.0,
+        }
+        yield stream_payload(
+            event="page_start",
+            pages=[current],
+            current_page=page_number,
+            total_pages=total_pages,
+            document_type=document_type,
+            started=started,
+            model_choice=choice,
+            page_preview=page_preview_data_uri(page_image),
+            batch_start_page=batch_start_page,
+            batch_end_page=batch_end_page,
+            backend=backend_name,
+        )
+
+        if choice == "OvisOCR2":
+            stream = ovis_adapter.infer_stream(page_image, active_prompt)
+        elif choice == "GLM-OCR":
+            stream = glm_adapter.infer_stream(page_image, active_prompt)
+        else:
+            assert_never(choice)
+
+        markdown = ""
+        for partial in stream:
+            markdown = partial
+            if choice == "OvisOCR2":
+                render = stream_safe_markdown(markdown)
+            else:
+                render = markdown
+            current = {
+                "page_number": page_number,
+                "markdown": markdown,
+                "render_markdown": render,
+                "status": "streaming",
+                "elapsed_seconds": round(time.perf_counter() - page_started, 3),
+            }
+            yield stream_payload(
+                event="stream",
+                pages=[current],
+                current_page=page_number,
+                total_pages=total_pages,
+                document_type=document_type,
+                started=started,
+                model_choice=choice,
+                batch_start_page=batch_start_page,
+                batch_end_page=batch_end_page,
+                backend=backend_name,
+            )
+
+        markdown = clean_truncated_repeats(markdown.strip())
+        if not markdown:
+            raise RuntimeError(f"The model returned an empty result for page {page_number}.")
+
+        if choice == "OvisOCR2":
+            render_final = materialize_bbox_images(markdown, page_image)
+        elif choice == "GLM-OCR":
+            render_final = markdown
+        else:
+            assert_never(choice)
+
+        completed_page = {
+            "page_number": page_number,
+            "markdown": markdown,
+            "render_markdown": render_final,
+            "status": "complete",
+            "elapsed_seconds": round(time.perf_counter() - page_started, 3),
+        }
+        completed_pages.append(completed_page)
+        print(
+            f"[ocr] page {page_number}/{total_pages} complete "
+            f"({len(markdown)} chars, {completed_page['elapsed_seconds']}s)",
+            flush=True,
+        )
+        yield stream_payload(
+            event="page_complete",
+            pages=[completed_page],
+            current_page=page_number,
+            total_pages=total_pages,
+            document_type=document_type,
+            started=started,
+            model_choice=choice,
+            batch_start_page=batch_start_page,
+            batch_end_page=batch_end_page,
+            backend=backend_name,
+        )
+
+    print(
+        f"[ocr] batch complete pages {batch_start_page}-{batch_end_page}/{total_pages}",
+        flush=True,
+    )
+    yield stream_payload(
+        event="complete",
+        pages=completed_pages,
+        current_page=batch_end_page,
+        total_pages=total_pages,
+        document_type=document_type,
+        started=started,
+        model_choice=choice,
+        batch_complete=True,
+        batch_start_page=batch_start_page,
+        batch_end_page=batch_end_page,
+        backend=backend_name,
+    )

backend/spaces_shim.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+
+try:
+    import spaces  # Must be imported before torch on Hugging Face ZeroGPU.
+except ImportError:  # Local development uses a no-op decorator.
+
+    class _LocalSpaces:
+        @staticmethod
+        def GPU(*decorator_args: Any, **decorator_kwargs: Any) -> Callable:
+            def decorate(function: Callable) -> Callable:
+                return function
+
+            if decorator_args and callable(decorator_args[0]) and len(decorator_args) == 1:
+                return decorator_args[0]
+            return decorate
+
+    spaces = _LocalSpaces()  # type: ignore[assignment]
+
+__all__ = ["spaces"]

backend/stream_protocol.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from backend.config import ModelChoice, hub_id_for
+
+
+def combine_pages(pages: list[dict[str, Any]], field: str) -> str:
+    if len(pages) <= 1:
+        return pages[0].get(field, "") if pages else ""
+    return "\n\n---\n\n".join(
+        f"<!-- Page {page['page_number']} -->\n\n{page.get(field, '')}" for page in pages
+    )
+
+
+def stream_payload(
+    *,
+    event: str,
+    pages: list[dict[str, Any]],
+    current_page: int,
+    total_pages: int,
+    document_type: str,
+    started: float,
+    model_choice: ModelChoice,
+    page_preview: str | None = None,
+    batch_complete: bool = False,
+    batch_start_page: int | None = None,
+    batch_end_page: int | None = None,
+    backend: str = "transformers",
+) -> dict[str, Any]:
+    return {
+        "event": event,
+        "markdown": combine_pages(pages, "markdown"),
+        "render_markdown": combine_pages(pages, "render_markdown"),
+        "pages": pages,
+        "current_page": current_page,
+        "total_pages": total_pages,
+        "document_type": document_type,
+        "page_preview": page_preview,
+        "batch_complete": batch_complete,
+        "batch_start_page": batch_start_page,
+        "batch_end_page": batch_end_page,
+        "char_count": sum(len(page.get("markdown", "")) for page in pages),
+        "elapsed_seconds": round(time.perf_counter() - started, 3),
+        "model": hub_id_for(model_choice),
+        "model_choice": model_choice,
+        "backend": backend,
+        "mode": "base",
+    }

dist/assets/__vite-browser-external-DYxpcVy9-BIHI7g3E.js

@@ -0,0 +1 @@
+const e={};export{e as default};

dist/assets/index-VoO5HFYT.css

@@ -0,0 +1 @@
+@import"https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500&family=Manrope:wght@400;500;600;700;800&display=swap";:root{--bg0: #071820;--bg1: #0b3d4a;--bg2: #125a63;--ink: #f2f7f8;--muted: #a7c2c7;--accent: #2ec4b6;--accent-2: #f4a261;--danger: #e76f51;--panel: rgba(8, 28, 34, .72);--line: rgba(174, 214, 220, .22);--shadow: 0 24px 60px rgba(0, 0, 0, .35);font-family:Manrope,sans-serif;color:var(--ink);background:var(--bg0)}*{box-sizing:border-box}html,body,#root{margin:0;min-height:100%}body{min-height:100vh;background:radial-gradient(1200px 600px at 10% -10%,rgba(46,196,182,.18),transparent 60%),radial-gradient(900px 500px at 90% 0%,rgba(244,162,97,.12),transparent 55%),linear-gradient(165deg,#071820,#0b3d4a 48%,#083038);background-attachment:fixed}.app{max-width:1400px;margin:0 auto;padding:2rem 1.25rem 3rem}.hero{margin-bottom:1.5rem}.eyebrow{margin:0 0 .5rem;letter-spacing:.12em;text-transform:uppercase;font-size:.75rem;color:var(--accent);font-weight:700}h1{margin:0;font-size:clamp(2rem,4vw,3.4rem);line-height:1.05;font-weight:800;letter-spacing:-.03em;max-width:16ch}.subtitle{margin:.85rem 0 0;max-width:42rem;color:var(--muted);font-size:1.05rem}.guidance{margin:.65rem 0 0;color:var(--ink);font-weight:600}.cta-row{display:flex;flex-wrap:wrap;gap:.75rem;align-items:center;margin-top:1.25rem}.btn{border:0;border-radius:999px;padding:.7rem 1.2rem;font:inherit;font-weight:700;cursor:pointer;transition:transform .15s ease,opacity .15s ease}.btn:disabled{opacity:.45;cursor:not-allowed}.btn:not(:disabled):hover{transform:translateY(-1px)}.btn.primary{background:var(--accent);color:#042229}.btn.secondary{background:transparent;color:var(--ink);border:1px solid var(--line)}.btn.danger{background:var(--danger);color:#fff}.model-toggle,.view-toggle{display:inline-flex;border:1px solid var(--line);border-radius:999px;overflow:hidden;background:#0003}.model-toggle button,.view-toggle button{border:0;background:transparent;color:var(--muted);font:inherit;font-weight:650;padding:.65rem .95rem;cursor:pointer}.model-toggle button.active,.view-toggle button.active{background:#2ec4b633;color:var(--ink)}.prompt-toggle{margin-top:.9rem;background:none;border:0;color:var(--muted);font:inherit;text-decoration:underline;cursor:pointer;padding:0}.prompt-box{display:block;width:min(100%,52rem);margin-top:.65rem;border-radius:12px;border:1px solid var(--line);background:#00000047;color:var(--ink);padding:.85rem 1rem;font:inherit;resize:vertical}.status{margin:.9rem 0 0;color:var(--accent-2);font-weight:600}.workspace{display:grid;grid-template-columns:minmax(280px,.9fr) minmax(320px,1.1fr);gap:1rem;min-height:min(70vh,820px)}.pane{background:var(--panel);border:1px solid var(--line);border-radius:18px;box-shadow:var(--shadow);-webkit-backdrop-filter:blur(10px);backdrop-filter:blur(10px);overflow:hidden;display:flex;flex-direction:column;min-height:520px}.pane-label{font-size:.75rem;letter-spacing:.08em;text-transform:uppercase;color:var(--muted);font-weight:700}.preview-pane{padding:1rem}.preview-image{width:100%;max-height:62vh;object-fit:contain;border-radius:12px;background:#00000040;margin-top:.75rem}.preview-fallback{margin-top:.75rem;min-height:280px;display:grid;place-content:center;gap:.4rem;text-align:center;color:var(--muted);border:1px dashed var(--line);border-radius:12px;padding:1rem}.examples{display:flex;flex-wrap:wrap;gap:.5rem;margin-top:auto;padding-top:1rem}.example-chip{border:1px solid var(--line);background:#ffffff0a;color:var(--ink);border-radius:999px;padding:.4rem .8rem;font:inherit;font-size:.85rem;cursor:pointer}.example-chip:hover:not(:disabled){border-color:var(--accent)}.result-toolbar{display:flex;justify-content:space-between;align-items:center;gap:1rem;padding:1rem 1rem .5rem}.markdown-source,.markdown-render{margin:0;padding:1rem 1.1rem 1.4rem;overflow:auto;flex:1}.markdown-source{font-family:JetBrains Mono,ui-monospace,monospace;font-size:.82rem;line-height:1.55;white-space:pre-wrap;color:#d7ecef}.markdown-render{line-height:1.65}.markdown-render :is(h1,h2,h3){line-height:1.2;margin:1rem 0 .5rem}.markdown-render table{border-collapse:collapse;width:100%;margin:.75rem 0;font-size:.92rem}.markdown-render th,.markdown-render td{border:1px solid var(--line);padding:.4rem .55rem}.markdown-render img{max-width:100%;border-radius:8px;margin:.75rem 0}.markdown-render .visual-placeholder{padding:.75rem;border:1px dashed var(--line);border-radius:8px;color:var(--muted);margin:.75rem 0}.markdown-render .muted{color:var(--muted)}@media(max-width:960px){.workspace{grid-template-columns:1fr}h1{max-width:none}}

dist/index.html

@@ -0,0 +1,47 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="theme-color" content="#0b3d4a" />
+    <meta
+      name="description"
+      content="Streaming OCR for Ebola contact-tracing documents — OvisOCR2 and GLM-OCR."
+    />
+    <link rel="icon" href="./favicon.ico" />
+    <title>OCR Capacity Building as a Service</title>
+    <script>
+      window.MathJax = {
+        options: {
+          skipHtmlTags: [
+            "script",
+            "noscript",
+            "style",
+            "textarea",
+            "code",
+            "annotation",
+            "annotation-xml",
+          ],
+        },
+        tex: {
+          inlineMath: [
+            ["\\(", "\\)"],
+            ["$", "$"],
+          ],
+          displayMath: [
+            ["\\[", "\\]"],
+          ],
+          processEscapes: true,
+        },
+        chtml: { matchFontHeight: false },
+        startup: { typeset: false },
+      };
+    </script>
+    <script defer src="./vendor/mathjax/tex-chtml-full.js"></script>
+    <script type="module" crossorigin src="./assets/index-hmRzNS5f.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-VoO5HFYT.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_AMS-Regular.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3de784d07b9fa8f104c10928a878ee879cf3305cae5195cba663c9c2bb0195eb
+size 40808

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_Calligraphic-Bold.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:af04542b29eaac04550a140c5f1760a649783989426f2540855bf4157819367d
+size 9908

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_Calligraphic-Regular.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:26683bf201fb258a2237d9754616de9d4ecf4cc1cd39dd1902476df7d75f1d16
+size 9600

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_Fraktur-Bold.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:721921bab0d001ebff0206c24cb5de6ca136467bf1843a7aa32030ba061d1e92
+size 22340

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_Fraktur-Regular.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:870673df72e70f87c91a5a317d558c2c3b54392264ad79bbadc6d424ae8765fe
+size 21480

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_Main-Bold.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:88b98cad3688915e50da55553ff6ad185e0dce134b47f176e91b100f8a9b175c
+size 34464

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_Main-Italic.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:355254db9ca10a09a3b5f0929d74eb4670f44fbe864c07526a06213e0a0caf6c
+size 20832

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_Main-Regular.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1cb1c39ea642f26a4dfed230b4aea1c3c218689421f6e9c0a7c1811693c4fa07
+size 34160

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_Math-BoldItalic.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ea8dbb1b02e6f730f55b4cb5d413b785b9f5c39807d0a0fa7da206a0824a457
+size 19776

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_Math-Italic.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a009bea404f7a500ded48f8b9ad9cf16e12504b3195dd9e25975289b8256b0f0
+size 19360

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_Math-Regular.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c01d3321e89b403c4b811aa153c4e618eda3421f92d8a072a02c8d190782a191
+size 19288

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_SansSerif-Bold.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:32792104b5ef69eded905b6d1598ed05d8087684d38e7a94d52e3c38ba16f47e
+size 15944

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_SansSerif-Italic.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fc6ddf5df402b263cfb158aed8e89972542c34b719cd87b1db30461985f7bd5b
+size 14628

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_SansSerif-Regular.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b418136e3b384baaadecb70bd3c48a8da9825210130b2897db808c44efc883cb
+size 12660

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_Script-Regular.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:af96f67d7accf5fd2a4a682d0b9f8b339f8ea6fe34c310c1694c8ba7f6ddc96f
+size 11852

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_Size1-Regular.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c49810b53ecc0d87d8028762c518924197dd9d3f905b08f99ea241301085b9cb
+size 5792

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_Size2-Regular.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:30e889b58cbc51adfbb038ab1a96dc4025aa3542a3cff7712fc55ece510675e2
+size 5464

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_Size3-Regular.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5cda41563a095bd70c78e2dda13d0f8cb922c71c90fffd0a0044c65173a66e83
+size 3244

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_Size4-Regular.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3bc6ecaae7ecf6f8d7f8ea07bddbaca8601e2cb6e89d6aef58e78d9f6d8a398f
+size 5148

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_Typewriter-Regular.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c56da8d69f1a0208b8e0703656c3264b6dd748bd452524c82b0385b60f6a68c1
+size 17604

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_Vector-Bold.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36e0d72d8a7afc696a3e7a5c7369807634640de9b02257bca447bdf126221a27
+size 1116

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_Vector-Regular.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:72bc573386dd1d48c5bbd286302ca9e3400c5eb0f298e7cfbf945b9d08fc688f
+size 1136

dist/vendor/mathjax/output/chtml/fonts/woff-v2/MathJax_Zero.woff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:481e39042508ae313a60618af1e37146ab93e9324c98e4c78b8f17fe55d41e0b
+size 1368

frontend/index.html

@@ -0,0 +1,46 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="theme-color" content="#0b3d4a" />
+    <meta
+      name="description"
+      content="Streaming OCR for Ebola contact-tracing documents — OvisOCR2 and GLM-OCR."
+    />
+    <link rel="icon" href="./favicon.ico" />
+    <title>OCR Capacity Building as a Service</title>
+    <script>
+      window.MathJax = {
+        options: {
+          skipHtmlTags: [
+            "script",
+            "noscript",
+            "style",
+            "textarea",
+            "code",
+            "annotation",
+            "annotation-xml",
+          ],
+        },
+        tex: {
+          inlineMath: [
+            ["\\(", "\\)"],
+            ["$", "$"],
+          ],
+          displayMath: [
+            ["\\[", "\\]"],
+          ],
+          processEscapes: true,
+        },
+        chtml: { matchFontHeight: false },
+        startup: { typeset: false },
+      };
+    </script>
+    <script defer src="./vendor/mathjax/tex-chtml-full.js"></script>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>