Sync DeepSeek OCR HF job code

ds-batch-ocr.py

@@ -0,0 +1,8 @@
+"""Thin entrypoint that delegates to the package implementation."""
+
+from ds_batch_ocr.cli import main
+
+
+if __name__ == "__main__":
+    main()
+

ds_batch_ocr/__init__.py

@@ -0,0 +1,6 @@
+"""DeepSeek OCR pipeline package."""
+
+from .cli import main
+
+__all__ = ["main"]
+

ds_batch_ocr/cli.py

@@ -0,0 +1,280 @@
+from __future__ import annotations
+
+import argparse
+import logging
+import os
+import sys
+from pathlib import Path
+from typing import Optional, Sequence
+
+from .config import ArtifactLocator, AssembleSettings, DescribeSettings, ExtractSettings, InferenceSettings
+from .dependencies import bootstrap
+from .logging_utils import configure_logging
+from .server import (
+    DeepSeekClient,
+    base_url_from_env,
+    launch_vllm,
+    should_launch_server,
+    shutdown_server,
+    wait_for_server,
+)
+from .stages import (
+    run_stage_assemble,
+    run_stage_describe,
+    run_stage_extract,
+)
+
+LOGGER = logging.getLogger(__name__)
+
+
+def parse_arguments(argv: Optional[Sequence[str]] = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="DeepSeek OCR HF Jobs pipeline")
+    parser.add_argument("--stage", choices=["extract", "describe", "assemble"], help="Pipeline stage to run")
+    parser.add_argument("--output-dir", help="Output directory for the current stage")
+    parser.add_argument("--stage1-dir", help="Path to stage1 outputs (for describe/assemble)")
+    parser.add_argument("--stage2-dir", help="Path to stage2 outputs (for assemble)")
+    parser.add_argument("--dataset-name", help="Dataset name for extract stage")
+    parser.add_argument("--dataset-config", help="Dataset config for extract stage")
+    parser.add_argument("--dataset-split", help="Dataset split for extract stage")
+    parser.add_argument("--max-samples", type=int, help="Max samples to process in extract stage")
+    parser.add_argument("--doc-prompt", help="Prompt for document extraction stage")
+    parser.add_argument("--figure-prompt", help="Prompt for figure description stage")
+    parser.add_argument("--doc-max-tokens", type=int, help="Max tokens for extraction stage")
+    parser.add_argument("--figure-max-tokens", type=int, help="Max tokens for description stage")
+    parser.add_argument("--doc-temperature", type=float, help="Sampling temperature for extraction stage")
+    parser.add_argument("--figure-temperature", type=float, help="Sampling temperature for description stage")
+    parser.add_argument(
+        "--no-streaming",
+        action="store_true",
+        help="Disable dataset streaming in extract stage",
+    )
+    parser.add_argument("--dataset-repo-id", help="Hugging Face dataset repo to upload assembled outputs")
+    parser.add_argument("--dataset-path-in-repo", help="Target path inside the dataset repo")
+    parser.add_argument("--dataset-branch", help="Dataset repo branch or revision to push to")
+    parser.add_argument("--dataset-commit-message", help="Commit message for dataset upload")
+    parser.add_argument("--dataset-repo-type", help="Repository type (defaults to 'dataset')")
+    return parser.parse_args(argv)
+
+
+def getenv_float(name: str, default: float) -> float:
+    value = os.environ.get(name)
+    if value is None:
+        return default
+    try:
+        return float(value)
+    except ValueError:
+        LOGGER.warning("Invalid float for %s=%s. Using default=%s", name, value, default)
+        return default
+
+
+def getenv_int(name: str, default: int) -> int:
+    value = os.environ.get(name)
+    if value is None:
+        return default
+    try:
+        return int(value)
+    except ValueError:
+        LOGGER.warning("Invalid int for %s=%s. Using default=%s", name, value, default)
+        return default
+
+
+def main(argv: Optional[Sequence[str]] = None) -> None:
+    configure_logging()
+    bootstrap()  # Ensure dependencies are installed and available.
+    args = parse_arguments(argv)
+
+    stage = (args.stage or os.environ.get("PIPELINE_STAGE", "extract")).lower()
+    if stage not in {"extract", "describe", "assemble"}:
+        raise ValueError(f"Unsupported stage: {stage}")
+
+    served_model_name = os.environ.get("SERVED_MODEL_NAME", "deepseek-ocr")
+    base_url = base_url_from_env()
+
+    launch_server = should_launch_server() and stage in {"extract", "describe"}
+    server_process: Optional[subprocess.Popen] = None
+
+    try:
+        if launch_server:
+            server_process = launch_vllm()
+
+        if stage in {"extract", "describe"}:
+            health_url = os.environ.get("HEALTH_URL", f"{base_url}/health")
+            LOGGER.info("Waiting for server at %s", health_url)
+            if not wait_for_server(health_url):
+                raise RuntimeError("vLLM server did not become ready in time")
+
+        if stage == "extract":
+            dataset_name = args.dataset_name or os.environ.get(
+                "DATASET_NAME", "HuggingFaceM4/FineVision"
+            )
+            dataset_config = args.dataset_config or os.environ.get(
+                "DATASET_CONFIG", "olmOCR-mix-0225-documents"
+            )
+            dataset_split = args.dataset_split or os.environ.get(
+                "DATASET_SPLIT", "train"
+            )
+            max_samples = args.max_samples
+            if max_samples is None:
+                max_samples = getenv_int("MAX_SAMPLES", 3)
+
+            doc_prompt = args.doc_prompt or os.environ.get(
+                "DOC_PROMPT",
+                "<image>\n<|grounding|>Convert this document to Markdown.",
+            )
+            output_dir = Path(
+                args.output_dir
+                or os.environ.get("STAGE1_OUTPUT_DIR")
+                or os.environ.get("OUTPUT_DIR", "./outputs/stage1")
+            )
+            doc_max_tokens = args.doc_max_tokens or getenv_int("DOC_MAX_TOKENS", 2048)
+            doc_temperature = (
+                args.doc_temperature
+                if args.doc_temperature is not None
+                else getenv_float("DOC_TEMPERATURE", 0.0)
+            )
+
+            extract_inference = InferenceSettings.from_env("extract")
+
+            client = DeepSeekClient(
+                base_url=base_url,
+                model_name=served_model_name,
+                max_tokens=doc_max_tokens,
+                temperature=doc_temperature,
+                request_timeout=extract_inference.request_timeout,
+                max_retries=extract_inference.max_retries,
+                retry_backoff_seconds=extract_inference.retry_backoff_seconds,
+                max_retry_wait_seconds=extract_inference.max_retry_wait_seconds,
+            )
+
+            settings = ExtractSettings(
+                dataset_name=dataset_name,
+                dataset_config=dataset_config,
+                dataset_split=dataset_split,
+                max_samples=max_samples,
+                prompt=doc_prompt,
+                max_tokens=doc_max_tokens,
+                temperature=doc_temperature,
+                output_dir=output_dir,
+                stream_dataset=not args.no_streaming,
+                served_model_name=served_model_name,
+                inference=extract_inference,
+                client=client,
+            )
+            run_stage_extract(settings)
+
+        elif stage == "describe":
+            stage1_dir = Path(
+                args.stage1_dir
+                or os.environ.get("STAGE1_DIR")
+                or os.environ.get("STAGE1_OUTPUT_DIR", "./outputs/stage1")
+            )
+            output_dir = Path(
+                args.output_dir
+                or os.environ.get("STAGE2_OUTPUT_DIR")
+                or os.environ.get("OUTPUT_DIR", "./outputs/stage2")
+            )
+            figure_prompt = args.figure_prompt or os.environ.get(
+                "FIGURE_PROMPT",
+                "<image>\nDescribe this image in detail",
+            )
+            figure_max_tokens = (
+                args.figure_max_tokens or getenv_int("FIGURE_MAX_TOKENS", 512)
+            )
+            figure_temperature = (
+                args.figure_temperature
+                if args.figure_temperature is not None
+                else getenv_float("FIGURE_TEMPERATURE", 0.0)
+            )
+
+            describe_inference = InferenceSettings.from_env("describe")
+
+            client = DeepSeekClient(
+                base_url=base_url,
+                model_name=served_model_name,
+                max_tokens=figure_max_tokens,
+                temperature=figure_temperature,
+                request_timeout=describe_inference.request_timeout,
+                max_retries=describe_inference.max_retries,
+                retry_backoff_seconds=describe_inference.retry_backoff_seconds,
+                max_retry_wait_seconds=describe_inference.max_retry_wait_seconds,
+            )
+
+            stage1_locator = ArtifactLocator.from_env("stage1", manifest_name="manifest.json")
+
+            settings = DescribeSettings(
+                stage1_dir=stage1_dir,
+                output_dir=output_dir,
+                prompt=figure_prompt,
+                max_tokens=figure_max_tokens,
+                temperature=figure_temperature,
+                client=client,
+                inference=describe_inference,
+                source_locator=stage1_locator,
+            )
+            run_stage_describe(settings)
+
+        elif stage == "assemble":
+            stage1_dir = Path(
+                args.stage1_dir
+                or os.environ.get("STAGE1_DIR")
+                or os.environ.get("STAGE1_OUTPUT_DIR", "./outputs/stage1")
+            )
+            stage2_dir = Path(
+                args.stage2_dir
+                or os.environ.get("STAGE2_DIR")
+                or os.environ.get("STAGE2_OUTPUT_DIR", "./outputs/stage2")
+            )
+            output_dir = Path(
+                args.output_dir
+                or os.environ.get("STAGE3_OUTPUT_DIR")
+                or os.environ.get("OUTPUT_DIR", "./outputs/stage3")
+            )
+
+            dataset_repo_id = args.dataset_repo_id or os.environ.get("ASSEMBLED_DATASET_REPO")
+            if dataset_repo_id:
+                dataset_repo_id = dataset_repo_id.strip() or None
+
+            dataset_path_in_repo = (
+                args.dataset_path_in_repo
+                or os.environ.get("ASSEMBLED_DATASET_PATH_IN_REPO")
+                or "data"
+            )
+            dataset_commit_message = (
+                args.dataset_commit_message
+                or os.environ.get("ASSEMBLED_DATASET_COMMIT_MESSAGE")
+            )
+            dataset_branch = args.dataset_branch or os.environ.get("ASSEMBLED_DATASET_BRANCH")
+            dataset_repo_type = (
+                args.dataset_repo_type
+                or os.environ.get("ASSEMBLED_DATASET_REPO_TYPE")
+                or "dataset"
+            )
+
+            stage1_locator = ArtifactLocator.from_env("stage1", manifest_name="manifest.json")
+            stage2_locator = ArtifactLocator.from_env(
+                "stage2", manifest_name="figure_descriptions.json"
+            )
+
+            settings = AssembleSettings(
+                stage1_dir=stage1_dir,
+                stage2_dir=stage2_dir,
+                output_dir=output_dir,
+                dataset_repo_id=dataset_repo_id,
+                dataset_path_in_repo=dataset_path_in_repo,
+                dataset_commit_message=dataset_commit_message,
+                dataset_branch=dataset_branch,
+                dataset_repo_type=dataset_repo_type,
+                stage1_locator=stage1_locator,
+                stage2_locator=stage2_locator,
+            )
+            run_stage_assemble(settings)
+
+    finally:
+        if server_process is not None:
+            shutdown_server(server_process)
+
+
+import subprocess  # noqa: E402
+
+__all__ = ["main", "parse_arguments", "getenv_float", "getenv_int"]
+

ds_batch_ocr/config.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+import logging
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional
+
+LOGGER = logging.getLogger(__name__)
+
+
+@dataclass
+class FigureMetadata:
+    figure_id: str
+    label: str
+    image_path: str
+    document_relative_path: str
+    bounding_box_norm: Dict[str, float]
+    bounding_box_norm_list: List[List[float]]
+    bounding_box_pixels: Dict[str, int]
+    description: Optional[str] = None
+
+
+@dataclass
+class DocumentMetadata:
+    sample_id: str
+    dataset_index: int
+    document_path: str
+    raw_response_path: str
+    source_image_path: str
+    figures: List[FigureMetadata] = field(default_factory=list)
+
+
+@dataclass
+class InferenceSettings:
+    max_batch_size: int = 4
+    max_concurrency: int = 4
+    request_timeout: int = 120
+    max_retries: int = 3
+    retry_backoff_seconds: float = 2.0
+    max_retry_wait_seconds: float = 60.0
+
+    @classmethod
+    def from_env(cls, stage: str) -> "InferenceSettings":
+        stage = stage.upper()
+        default = cls()
+
+        def read_int(*keys: str, default_value: int) -> int:
+            return _read_env(*keys, default=default_value, cast=int)
+
+        def read_float(*keys: str, default_value: float) -> float:
+            return _read_env(*keys, default=default_value, cast=float)
+
+        return cls(
+            max_batch_size=max(
+                1,
+                read_int(f"{stage}_BATCH_SIZE", "PIPELINE_BATCH_SIZE", default_value=default.max_batch_size),
+            ),
+            max_concurrency=max(
+                1,
+                read_int(
+                    f"{stage}_MAX_CONCURRENCY",
+                    "PIPELINE_MAX_CONCURRENCY",
+                    default_value=default.max_concurrency,
+                ),
+            ),
+            request_timeout=max(
+                1,
+                read_int(
+                    f"{stage}_REQUEST_TIMEOUT",
+                    "PIPELINE_REQUEST_TIMEOUT",
+                    default_value=default.request_timeout,
+                ),
+            ),
+            max_retries=max(
+                0,
+                read_int(
+                    f"{stage}_MAX_RETRIES",
+                    "PIPELINE_MAX_RETRIES",
+                    default_value=default.max_retries,
+                ),
+            ),
+            retry_backoff_seconds=max(
+                0.0,
+                read_float(
+                    f"{stage}_RETRY_BACKOFF_SECONDS",
+                    "PIPELINE_RETRY_BACKOFF_SECONDS",
+                    default_value=default.retry_backoff_seconds,
+                ),
+            ),
+            max_retry_wait_seconds=max(
+                1.0,
+                read_float(
+                    f"{stage}_MAX_RETRY_WAIT_SECONDS",
+                    "PIPELINE_MAX_RETRY_WAIT_SECONDS",
+                    default_value=default.max_retry_wait_seconds,
+                ),
+            ),
+        )
+
+
+@dataclass
+class ArtifactLocator:
+    strategy: str = "local"
+    repo_id: Optional[str] = None
+    job_id: Optional[str] = None
+    job_owner: Optional[str] = None
+    uri: Optional[str] = None
+    manifest_name: str = "manifest.json"
+
+    @classmethod
+    def from_env(cls, stage: str, *, manifest_name: str) -> "ArtifactLocator":
+        stage = stage.upper()
+
+        def read_str(*keys: str) -> Optional[str]:
+            for key in keys:
+                value = os.environ.get(key)
+                if value:
+                    value = value.strip()
+                    if value:
+                        return value
+            return None
+
+        repo_id = read_str(f"{stage}_JOB_REPO", f"{stage}_REPO_ID")
+        job_id = read_str(f"{stage}_JOB_ID")
+        job_owner = read_str(f"{stage}_JOB_OWNER")
+        uri = read_str(f"{stage}_ARTIFACT_URI", f"{stage}_S3_URI")
+        manifest_override = read_str(f"{stage}_MANIFEST_NAME")
+        explicit_strategy = read_str(f"{stage}_ARTIFACT_STRATEGY")
+        pipeline_strategy = read_str("PIPELINE_ARTIFACT_STRATEGY")
+
+        strategy = (explicit_strategy or pipeline_strategy or "").lower()
+        if not strategy:
+            if uri and uri.startswith("s3://"):
+                strategy = "s3"
+            elif repo_id or (job_id and job_owner):
+                strategy = "hf-hub"
+            else:
+                strategy = "local"
+
+        locator = cls(
+            strategy=strategy,
+            repo_id=repo_id,
+            job_id=job_id,
+            job_owner=job_owner,
+            uri=uri,
+            manifest_name=manifest_override or manifest_name,
+        )
+
+        LOGGER.debug(
+            "Artifact locator for %s: %s",
+            stage,
+            {
+                "strategy": locator.strategy,
+                "repo_id": locator.repo_id,
+                "job_id": locator.job_id,
+                "job_owner": locator.job_owner,
+                "uri": locator.uri,
+                "manifest": locator.manifest_name,
+            },
+        )
+        return locator
+
+
+@dataclass
+class ExtractSettings:
+    dataset_name: str
+    dataset_config: str
+    dataset_split: str
+    max_samples: Optional[int]
+    prompt: str
+    max_tokens: int
+    temperature: float
+    output_dir: Path
+    stream_dataset: bool
+    served_model_name: str
+    inference: InferenceSettings = field(default_factory=InferenceSettings)
+    client: "DeepSeekClient"
+
+
+@dataclass
+class DescribeSettings:
+    stage1_dir: Path
+    output_dir: Path
+    prompt: str
+    max_tokens: int
+    temperature: float
+    client: "DeepSeekClient"
+    inference: InferenceSettings = field(default_factory=InferenceSettings)
+    source_locator: ArtifactLocator = field(default_factory=ArtifactLocator)
+
+
+@dataclass
+class AssembleSettings:
+    stage1_dir: Path
+    stage2_dir: Path
+    output_dir: Path
+    dataset_repo_id: Optional[str]
+    dataset_path_in_repo: str
+    dataset_commit_message: Optional[str]
+    dataset_branch: Optional[str]
+    dataset_repo_type: str
+    stage1_locator: ArtifactLocator = field(default_factory=ArtifactLocator)
+    stage2_locator: ArtifactLocator = field(default_factory=ArtifactLocator)
+
+
+__all__ = [
+    "FigureMetadata",
+    "DocumentMetadata",
+    "InferenceSettings",
+    "ArtifactLocator",
+    "ExtractSettings",
+    "DescribeSettings",
+    "AssembleSettings",
+]
+
+
+def _read_env(*keys: str, default, cast):
+    for key in keys:
+        raw = os.environ.get(key)
+        if raw is None:
+            continue
+        try:
+            return cast(raw)
+        except (TypeError, ValueError):
+            LOGGER.warning("Invalid value for %s=%s; using default=%s", key, raw, default)
+    return default
+

ds_batch_ocr/dependencies.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import logging
+import subprocess
+import sys
+from typing import Any, Dict, Sequence
+
+LOGGER = logging.getLogger(__name__)
+
+DEFAULT_DEPENDENCIES: Sequence[str] = (
+    "datasets",
+    "huggingface_hub",
+    "pillow",
+    "requests",
+)
+
+_CACHE: Dict[str, Any] | None = None
+
+
+def ensure_packages(packages: Sequence[str]) -> None:
+    missing: list[str] = []
+    for package in packages:
+        module_name = "PIL" if package == "pillow" else package
+        try:
+            __import__(module_name)
+        except ModuleNotFoundError:
+            missing.append(package)
+
+    if not missing:
+        return
+
+    LOGGER.info("Installing missing packages: %s", ", ".join(missing))
+    subprocess.run([sys.executable, "-m", "pip", "install", *missing], check=True)
+
+
+def bootstrap() -> Dict[str, Any]:
+    global _CACHE
+    if _CACHE is None:
+        ensure_packages(DEFAULT_DEPENDENCIES)
+
+        from datasets import load_dataset as _load_dataset  # type: ignore
+        import requests as _requests  # type: ignore
+        from huggingface_hub import (  # type: ignore
+            HfApi as _HfApi,
+            create_repo as _create_repo,
+            snapshot_download as _snapshot_download,
+        )
+        from PIL import Image as _Image  # type: ignore
+
+        _CACHE = {
+            "load_dataset": _load_dataset,
+            "requests": _requests,
+            "HfApi": _HfApi,
+            "create_repo": _create_repo,
+            "snapshot_download": _snapshot_download,
+            "Image": _Image,
+        }
+    return _CACHE.copy()
+
+
+def get_dependency(name: str) -> Any:
+    cache = bootstrap()
+    if name not in cache:
+        raise KeyError(f"Unknown dependency requested: {name}")
+    return cache[name]
+
+
+__all__ = [
+    "DEFAULT_DEPENDENCIES",
+    "ensure_packages",
+    "bootstrap",
+    "get_dependency",
+]
+

ds_batch_ocr/document.py

@@ -0,0 +1,272 @@
+from __future__ import annotations
+
+import ast
+import base64
+import json
+import re
+from io import BytesIO
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional, Tuple
+
+from .config import FigureMetadata
+from .dependencies import bootstrap
+
+deps = bootstrap()
+Image = deps["Image"]
+
+GROUNDING_PATTERN = re.compile(
+    r"<\|ref\|>(.*?)<\|/ref\|><\|det\|>(.*?)<\|/det\|>",
+    re.DOTALL,
+)
+
+FIGURE_MARKDOWN_PATTERN = re.compile(
+    r"!\[Figure (?P<figure_id>[^\]]+)\]\((?P<path>[^)]+)\)"
+)
+
+
+def encode_image(image: "Image.Image") -> str:
+    buffer = BytesIO()
+    image.save(buffer, format="PNG")
+    return base64.b64encode(buffer.getvalue()).decode("utf-8")
+
+
+def extract_grounding_blocks(text: str) -> List[Dict[str, Any]]:
+    matches: List[Dict[str, Any]] = []
+    for match in GROUNDING_PATTERN.finditer(text):
+        label = match.group(1).strip()
+        details = match.group(2).strip()
+        try:
+            coordinates = ast.literal_eval(details)
+        except Exception:
+            coordinates = None
+        matches.append(
+            {
+                "label": label,
+                "coordinates": coordinates,
+                "raw": match.group(0),
+                "span": match.span(),
+            }
+        )
+    return matches
+
+
+def flatten_boxes(coordinates: Any) -> List[List[float]]:
+    boxes: List[List[float]] = []
+    if coordinates is None:
+        return boxes
+    if isinstance(coordinates, (list, tuple)):
+        for item in coordinates:
+            if isinstance(item, (list, tuple)) and len(item) == 4:
+                boxes.append([float(value) for value in item])
+            elif isinstance(item, dict):
+                boxes.extend(flatten_boxes(item.get("bbox")))
+    elif isinstance(coordinates, dict):
+        boxes.extend(flatten_boxes(coordinates.get("bbox")))
+    return boxes
+
+
+def merge_boxes(boxes: List[List[float]]) -> Optional[List[float]]:
+    if not boxes:
+        return None
+    x1 = min(box[0] for box in boxes)
+    y1 = min(box[1] for box in boxes)
+    x2 = max(box[2] for box in boxes)
+    y2 = max(box[3] for box in boxes)
+    return [x1, y1, x2, y2]
+
+
+def clamp(value: int, lower: int, upper: int) -> int:
+    return max(lower, min(upper, value))
+
+
+def normalized_to_pixels(box: List[float], width: int, height: int) -> Optional[List[int]]:
+    if len(box) != 4 or width <= 0 or height <= 0:
+        return None
+    x1 = clamp(int(round(box[0] / 999.0 * width)), 0, width)
+    y1 = clamp(int(round(box[1] / 999.0 * height)), 0, height)
+    x2 = clamp(int(round(box[2] / 999.0 * width)), 0, width)
+    y2 = clamp(int(round(box[3] / 999.0 * height)), 0, height)
+    if x2 <= x1 or y2 <= y1:
+        return None
+    return [x1, y1, x2, y2]
+
+
+def postprocess_markdown(text: str) -> str:
+    cleaned = (
+        text.replace("\\coloneqq", ":=")
+        .replace("\\eqqcolon", "=:")
+        .replace("<|image_pad|>", "")
+    )
+    cleaned = re.sub(r"\n{3,}", "\n\n", cleaned)
+    return cleaned.strip()
+
+
+def apply_replacements(text: str, replacements: List[Tuple[int, int, str]]) -> str:
+    if not replacements:
+        return postprocess_markdown(text)
+    sorted_replacements = sorted(replacements, key=lambda item: item[0])
+    segments: List[str] = []
+    cursor = 0
+    for start, end, replacement in sorted_replacements:
+        segments.append(text[cursor:start])
+        segments.append(replacement)
+        cursor = end
+    segments.append(text[cursor:])
+    return postprocess_markdown("".join(segments))
+
+
+def save_figure(
+    image: "Image.Image",
+    sample_dir: Path,
+    sample_id: str,
+    figure_index: int,
+    boxes: List[List[float]],
+    label: str,
+) -> Optional[FigureMetadata]:
+    merged_box = merge_boxes(boxes)
+    if not merged_box:
+        return None
+    width, height = image.size
+    pixel_box = normalized_to_pixels(merged_box, width, height)
+    if not pixel_box:
+        return None
+    x1, y1, x2, y2 = pixel_box
+    crop = image.crop((x1, y1, x2, y2))
+
+    figures_dir = sample_dir / "figures"
+    figures_dir.mkdir(parents=True, exist_ok=True)
+
+    figure_id = f"{sample_id}_fig{figure_index:02d}"
+    figure_filename = f"{figure_id}.png"
+    figure_relative_doc_path = Path("figures") / figure_filename
+    full_path = figures_dir / figure_filename
+    crop.save(full_path)
+
+    norm_box = [value / 999.0 for value in merged_box]
+    bounding_box_norm = {
+        "x1": norm_box[0],
+        "y1": norm_box[1],
+        "x2": norm_box[2],
+        "y2": norm_box[3],
+    }
+    bounding_box_pixels = {"x1": x1, "y1": y1, "x2": x2, "y2": y2}
+
+    return FigureMetadata(
+        figure_id=figure_id,
+        label=label,
+        image_path=(Path(sample_id) / figure_relative_doc_path).as_posix(),
+        document_relative_path=figure_relative_doc_path.as_posix(),
+        bounding_box_norm=bounding_box_norm,
+        bounding_box_norm_list=[[float(v) for v in box] for box in boxes],
+        bounding_box_pixels=bounding_box_pixels,
+    )
+
+
+def write_text(path: Path, content: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content, encoding="utf-8")
+
+
+def write_json(path: Path, payload: Dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as handle:
+        json.dump(payload, handle, indent=2, ensure_ascii=False)
+
+
+def write_jsonl(path: Path, rows: Iterable[Dict[str, Any]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as handle:
+        for row in rows:
+            handle.write(json.dumps(row, ensure_ascii=False))
+            handle.write("\n")
+
+
+def build_document_markdown(
+    image: "Image.Image",
+    response_text: str,
+    sample_dir: Path,
+    sample_id: str,
+) -> Tuple[str, List[FigureMetadata]]:
+    blocks = extract_grounding_blocks(response_text)
+    replacements: List[Tuple[int, int, str]] = []
+    figures: List[FigureMetadata] = []
+    figure_index = 1
+
+    for block in blocks:
+        label = block["label"].lower()
+        start, end = block["span"]
+        if label == "image":
+            boxes = flatten_boxes(block["coordinates"])
+            figure_metadata = save_figure(
+                image=image,
+                sample_dir=sample_dir,
+                sample_id=sample_id,
+                figure_index=figure_index,
+                boxes=boxes,
+                label=block["label"],
+            )
+            if figure_metadata:
+                figures.append(figure_metadata)
+                replacements.append(
+                    (
+                        start,
+                        end,
+                        f"![Figure {figure_metadata.figure_id}]({figure_metadata.document_relative_path})",
+                    )
+                )
+                figure_index += 1
+            else:
+                replacements.append((start, end, ""))
+        else:
+            replacements.append((start, end, ""))
+
+    markdown = apply_replacements(response_text, replacements)
+    return markdown, figures
+
+
+def enrich_markdown_with_captions(
+    markdown: str,
+    description_map: Dict[str, Dict[str, Any]],
+) -> str:
+    used: set[str] = set()
+
+    def replace(match: re.Match[str]) -> str:
+        figure_id = match.group("figure_id").strip()
+        path = match.group("path").strip()
+        entry = description_map.get(figure_id)
+        if not entry:
+            return match.group(0)
+
+        description = entry.get("description", "").strip()
+        if not description:
+            return match.group(0)
+
+        alt_text = f"Figure {figure_id}: {description}"
+        rendered = f"![{alt_text}]({path})"
+        if figure_id not in used:
+            rendered += f"\n\n*Figure {figure_id}: {description}*\n"
+            used.add(figure_id)
+        return rendered
+
+    return FIGURE_MARKDOWN_PATTERN.sub(replace, markdown)
+
+
+__all__ = [
+    "encode_image",
+    "extract_grounding_blocks",
+    "flatten_boxes",
+    "merge_boxes",
+    "normalized_to_pixels",
+    "postprocess_markdown",
+    "apply_replacements",
+    "save_figure",
+    "write_text",
+    "write_json",
+    "write_jsonl",
+    "build_document_markdown",
+    "enrich_markdown_with_captions",
+    "FigureMetadata",
+    "GROUNDING_PATTERN",
+    "FIGURE_MARKDOWN_PATTERN",
+]
+

ds_batch_ocr/hf_io.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+import logging
+import tarfile
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Optional
+
+from .config import ArtifactLocator
+from .dependencies import bootstrap
+
+deps = bootstrap()
+snapshot_download = deps["snapshot_download"]
+create_repo = deps["create_repo"]
+HfApi = deps["HfApi"]
+
+LOGGER = logging.getLogger(__name__)
+
+
+def unpack_archives(target_dir: Path) -> None:
+    for archive in list(target_dir.glob("**/*.tar.gz")):
+        LOGGER.info("Extracting archive %s", archive)
+        with tarfile.open(archive, "r:gz") as tar:
+            tar.extractall(archive.parent)
+        archive.unlink()
+
+
+def download_job_artifact(repo_id: str, target_dir: Path) -> None:
+    LOGGER.info("Downloading job artifact %s -> %s", repo_id, target_dir)
+    snapshot_download(
+        repo_id=repo_id,
+        local_dir=target_dir,
+        local_dir_use_symlinks=False,
+        ignore_patterns=("logs/**",),
+    )
+    unpack_archives(target_dir)
+
+
+def resolve_stage_dir(base_dir: Path, locator: ArtifactLocator) -> Path:
+    base_dir.mkdir(parents=True, exist_ok=True)
+
+    def locate_manifest(candidate: Path) -> Optional[Path]:
+        manifest_name = locator.manifest_name or "manifest.json"
+        manifest_path = candidate / manifest_name
+        return manifest_path if manifest_path.exists() else None
+
+    manifest_path = locate_manifest(base_dir)
+    if manifest_path:
+        return base_dir
+
+    strategy = (locator.strategy or "local").lower()
+    if strategy == "local":
+        LOGGER.debug("Using local artifact locator for %s", base_dir)
+    elif strategy in {"hf-hub", "huggingface", "hub"}:
+        repo_id = locator.repo_id
+        if locator.uri:
+            repo_id = locator.uri
+        if repo_id:
+            download_job_artifact(repo_id, base_dir)
+        elif locator.job_id and locator.job_owner:
+            download_job_artifact(f"jobs/{locator.job_owner}/{locator.job_id}", base_dir)
+        else:
+            LOGGER.debug("HF locator missing repo or job identifiers; skipping download.")
+    elif strategy == "s3":
+        if locator.uri:
+            LOGGER.warning(
+                "S3 artifact download is not yet implemented. uri=%s", locator.uri
+            )
+        else:
+            LOGGER.warning("S3 artifact locator missing uri; nothing to download.")
+    else:
+        LOGGER.warning(
+            "Unknown artifact locator strategy '%s'; falling back to local files.",
+            locator.strategy,
+        )
+
+    manifest_path = locate_manifest(base_dir)
+    if manifest_path:
+        return base_dir
+
+    outputs_dir = base_dir / "outputs"
+    if locate_manifest(outputs_dir):
+        return outputs_dir
+
+    return base_dir
+
+
+def maybe_upload_dataset(
+    *,
+    output_dir: Path,
+    repo_id: Optional[str],
+    repo_type: str,
+    path_in_repo: str,
+    commit_message: Optional[str],
+    revision: Optional[str],
+) -> None:
+    if not repo_id:
+        LOGGER.info("No dataset repo provided; skipping upload.")
+        return
+
+    commit_message = commit_message or (
+        "Add assembled DeepSeek OCR dataset " + datetime.utcnow().isoformat() + "Z"
+    )
+
+    token = env_or_none("HF_TOKEN")
+    LOGGER.info("Ensuring %s repo exists: repo_id=%s", repo_type, repo_id)
+    create_repo(
+        repo_id=repo_id,
+        repo_type=repo_type,
+        exist_ok=True,
+        token=token,
+    )
+
+    LOGGER.info(
+        "Uploading assembled outputs to %s (path_in_repo=%s, revision=%s)",
+        repo_id,
+        path_in_repo,
+        revision,
+    )
+    HfApi().upload_folder(
+        folder_path=str(output_dir),
+        repo_id=repo_id,
+        repo_type=repo_type,
+        path_in_repo=path_in_repo or "",
+        commit_message=commit_message,
+        revision=revision,
+        token=token,
+    )
+
+
+def env_or_none(name: str) -> Optional[str]:
+    value = os.environ.get(name)
+    if value:
+        value = value.strip()
+    return value or None
+
+
+import os
+
+__all__ = [
+    "unpack_archives",
+    "download_job_artifact",
+    "resolve_stage_dir",
+    "maybe_upload_dataset",
+]
+

ds_batch_ocr/logging_utils.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import logging
+import os
+
+
+def configure_logging() -> None:
+    level = os.environ.get("LOG_LEVEL", "INFO").upper()
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+    )
+
+
+__all__ = ["configure_logging"]
+

ds_batch_ocr/server.py

@@ -0,0 +1,354 @@
+from __future__ import annotations
+
+import logging
+import os
+import signal
+import subprocess
+import threading
+import time
+from typing import Any, Dict, List, Optional, Sequence
+
+from .dependencies import bootstrap
+from .document import encode_image
+
+deps = bootstrap()
+requests = deps["requests"]
+
+LOGGER = logging.getLogger(__name__)
+
+
+def _stream_output(pipe, prefix: str) -> None:
+    try:
+        for line in iter(pipe.readline, ""):
+            print(f"[{prefix}] {line.rstrip()}", flush=True)
+    finally:
+        pipe.close()
+
+
+def launch_vllm() -> subprocess.Popen:
+    model_id = os.environ.get("MODEL_ID", "deepseek-ai/DeepSeek-OCR")
+    served_name = os.environ.get("SERVED_MODEL_NAME", "deepseek-ocr")
+    port = os.environ.get("PORT", "8080")
+    host = os.environ.get("HOST", "0.0.0.0")
+
+    cmd: List[str] = [
+        "vllm",
+        "serve",
+        "--model",
+        model_id,
+        "--served-model-name",
+        served_name,
+        "--tensor-parallel-size",
+        os.environ.get("TENSOR_PARALLEL_SIZE", "1"),
+        "--max-model-len",
+        os.environ.get("MAX_MODEL_LEN", "4096"),
+        "--gpu-memory-utilization",
+        os.environ.get("GPU_MEMORY_UTILIZATION", "0.85"),
+        "--port",
+        port,
+        "--host",
+        host,
+        "--trust-remote-code",
+        "--enable-chunked-prefill",
+    ]
+
+    extra_server_args = os.environ.get("EXTRA_VLLM_ARGS")
+    if extra_server_args:
+        cmd.extend(extra_server_args.split())
+
+    LOGGER.info("Launching vLLM server with command: %s", " ".join(cmd))
+    process = subprocess.Popen(
+        cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        bufsize=1,
+    )
+
+    threads = []
+    for name, pipe in (("STDOUT", process.stdout), ("STDERR", process.stderr)):
+        if pipe is not None:
+            thread = threading.Thread(
+                target=_stream_output,
+                args=(pipe, f"vLLM {name}"),
+                daemon=True,
+            )
+            thread.start()
+            threads.append(thread)
+
+    process._log_threads = threads  # type: ignore[attr-defined]
+    return process
+
+
+def shutdown_server(server_process: subprocess.Popen) -> None:
+    LOGGER.info("Shutting down vLLM server")
+    server_process.send_signal(signal.SIGTERM)
+    try:
+        server_process.wait(timeout=30)
+    except subprocess.TimeoutExpired:
+        LOGGER.warning("Server did not exit in time, sending SIGKILL")
+        server_process.kill()
+
+    log_threads = getattr(server_process, "_log_threads", [])
+    for thread in log_threads:
+        thread.join(timeout=1)
+
+
+def wait_for_server(url: str, timeout_s: int = 300, interval_s: int = 5) -> bool:
+    deadline = time.time() + timeout_s
+    while time.time() < deadline:
+        try:
+            response = requests.get(url, timeout=5)
+            if response.ok:
+                return True
+        except Exception:
+            pass
+        time.sleep(interval_s)
+    return False
+
+
+def should_launch_server() -> bool:
+    return os.environ.get("SKIP_SERVER_LAUNCH", "").lower() not in {"1", "true", "yes"}
+
+
+def base_url_from_env() -> str:
+    port = os.environ.get("PORT", "8080")
+    default_url = f"http://127.0.0.1:{port}"
+    return os.environ.get("BASE_URL", default_url)
+
+
+def prepare_payload(
+    image: "Image.Image",
+    served_name: str,
+    prompt: str,
+    max_tokens: int,
+    temperature: float,
+) -> Dict[str, Any]:
+    return {
+        "model": served_name,
+        "messages": [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": prompt},
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": f"data:image/png;base64,{encode_image(image)}"},
+                    },
+                ],
+            }
+        ],
+        "max_tokens": max_tokens,
+        "temperature": temperature,
+    }
+
+
+class DeepSeekClient:
+    def __init__(
+        self,
+        base_url: str,
+        model_name: str,
+        max_tokens: int,
+        temperature: float,
+        *,
+        request_timeout: int = 120,
+        max_retries: int = 3,
+        retry_backoff_seconds: float = 2.0,
+        max_retry_wait_seconds: float = 60.0,
+        backend: Optional[str] = None,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.model_name = model_name
+        self.default_max_tokens = max_tokens
+        self.default_temperature = temperature
+        self.default_request_timeout = request_timeout
+        self.max_retries = max(0, max_retries)
+        self.retry_backoff_seconds = max(0.0, retry_backoff_seconds)
+        self.max_retry_wait_seconds = max_retry_wait_seconds
+        self._thread_local = threading.local()
+        self.backend = (backend or os.environ.get("DEEPSEEK_INFERENCE_MODE", "http")).lower()
+        self._llm = None
+        self._sampling_params_cls = None
+        if self.backend == "vllm":
+            try:
+                from vllm import LLM, SamplingParams  # type: ignore
+            except ImportError as exc:  # pragma: no cover - runtime safeguard
+                raise RuntimeError(
+                    "DEEPSEEK_INFERENCE_MODE=vllm requires the vllm package to be installed."
+                ) from exc
+
+            model_id = os.environ.get("MODEL_ID", model_name)
+            tensor_parallel = int(os.environ.get("TENSOR_PARALLEL_SIZE", "1"))
+            trust_remote_code = os.environ.get("VLLM_TRUST_REMOTE_CODE", "1").lower() in {
+                "1",
+                "true",
+                "yes",
+            }
+            llm_kwargs: Dict[str, Any] = {
+                "model": model_id,
+                "tensor_parallel_size": tensor_parallel,
+                "trust_remote_code": trust_remote_code,
+            }
+            mm_cache_gb = os.environ.get("VLLM_MM_CACHE_GB")
+            if mm_cache_gb:
+                try:
+                    llm_kwargs["mm_processor_cache_gb"] = float(mm_cache_gb)
+                except ValueError:
+                    LOGGER.warning("Invalid VLLM_MM_CACHE_GB=%s; ignoring.", mm_cache_gb)
+            self._llm = LLM(**llm_kwargs)
+            self._sampling_params_cls = SamplingParams
+
+    def _get_session(self) -> Any:
+        session = getattr(self._thread_local, "session", None)
+        if session is None:
+            session = requests.Session()
+            self._thread_local.session = session
+        return session
+
+    def _perform_request(
+        self,
+        payload: Dict[str, Any],
+        request_timeout: int,
+    ) -> Dict[str, Any]:
+        attempts = self.max_retries + 1
+        for attempt in range(1, attempts + 1):
+            try:
+                session = self._get_session()
+                response = session.post(
+                    f"{self.base_url}/v1/chat/completions",
+                    json=payload,
+                    timeout=request_timeout,
+                )
+                response.raise_for_status()
+                return response.json()
+            except Exception as exc:  # pragma: no cover - defensive logging
+                if attempt >= attempts:
+                    LOGGER.error("DeepSeek request exhausted retries: %s", exc)
+                    raise
+                backoff = min(
+                    self.retry_backoff_seconds * (2 ** (attempt - 1)),
+                    self.max_retry_wait_seconds,
+                )
+                LOGGER.warning(
+                    "DeepSeek request failed (attempt %s/%s): %s. Retrying in %.2fs",
+                    attempt,
+                    attempts,
+                    exc,
+                    backoff,
+                )
+                time.sleep(backoff)
+        raise RuntimeError("Unreachable")  # pragma: no cover
+
+    def infer(
+        self,
+        image: "Image.Image",
+        prompt: str,
+        max_tokens: Optional[int] = None,
+        temperature: Optional[float] = None,
+        request_timeout: Optional[int] = None,
+    ) -> str:
+        payload = prepare_payload(
+            image=image,
+            served_name=self.model_name,
+            prompt=prompt,
+            max_tokens=max_tokens or self.default_max_tokens,
+            temperature=(
+                temperature if temperature is not None else self.default_temperature
+            ),
+        )
+        if self.backend == "vllm":
+            responses = self.infer_batch(
+                [
+                    {
+                        "image": image,
+                        "prompt": prompt,
+                        "max_tokens": max_tokens or self.default_max_tokens,
+                        "temperature": (
+                            temperature if temperature is not None else self.default_temperature
+                        ),
+                    }
+                ]
+            )
+            return responses[0]
+
+        effective_timeout = request_timeout or self.default_request_timeout
+        result = self._perform_request(payload, effective_timeout)
+        return result["choices"][0]["message"]["content"]
+
+    def infer_batch(self, requests_data: Sequence[Dict[str, Any]]) -> List[str]:
+        if not requests_data:
+            return []
+
+        if self.backend == "vllm":
+            assert self._llm is not None and self._sampling_params_cls is not None  # for mypy
+            base_req = requests_data[0]
+            sampling = self._sampling_params_cls(
+                temperature=base_req.get("temperature", self.default_temperature),
+                max_tokens=base_req.get("max_tokens", self.default_max_tokens),
+                top_p=base_req.get("top_p", 1.0),
+            )
+            llm_inputs = []
+            for req in requests_data:
+                if req.get("max_tokens") != base_req.get("max_tokens"):
+                    LOGGER.debug(
+                        "Mixed max_tokens in batch; using first value %s",
+                        base_req.get("max_tokens"),
+                    )
+                if req.get("temperature") != base_req.get("temperature"):
+                    LOGGER.debug(
+                        "Mixed temperature in batch; using first value %s",
+                        base_req.get("temperature"),
+                    )
+                llm_inputs.append(
+                    {
+                        "prompt": req.get("prompt", ""),
+                        "multi_modal_data": {"image": req["image"]},
+                    }
+                )
+            outputs = self._llm.generate(llm_inputs, sampling)
+            results: List[str] = []
+            for output in outputs:
+                if not output.outputs:
+                    results.append("")
+                else:
+                    results.append(output.outputs[0].text)
+            return results
+
+        responses: List[str] = []
+        for req in requests_data:
+            responses.append(
+                self.infer(
+                    image=req["image"],
+                    prompt=req.get("prompt", ""),
+                    max_tokens=req.get("max_tokens"),
+                    temperature=req.get("temperature"),
+                    request_timeout=req.get("request_timeout"),
+                )
+            )
+        return responses
+
+    def close(self) -> None:
+        session = getattr(self._thread_local, "session", None)
+        if session is not None:
+            try:
+                session.close()
+            finally:
+                delattr(self._thread_local, "session")
+        if self._llm is not None:
+            try:
+                shutdown = getattr(self._llm, "shutdown", None)
+                if callable(shutdown):
+                    shutdown()
+            finally:
+                self._llm = None
+
+
+__all__ = [
+    "launch_vllm",
+    "shutdown_server",
+    "wait_for_server",
+    "should_launch_server",
+    "base_url_from_env",
+    "DeepSeekClient",
+]
+

ds_batch_ocr/stages.py

@@ -0,0 +1,602 @@
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import shutil
+
+from .config import (
+    AssembleSettings,
+    DescribeSettings,
+    DocumentMetadata,
+    ExtractSettings,
+    FigureMetadata,
+)
+from .dependencies import bootstrap
+from .document import (
+    build_document_markdown,
+    enrich_markdown_with_captions,
+    write_json,
+    write_jsonl,
+    write_text,
+)
+from .hf_io import maybe_upload_dataset, resolve_stage_dir
+
+deps = bootstrap()
+load_dataset = deps["load_dataset"]
+Image = deps["Image"]
+
+LOGGER = logging.getLogger(__name__)
+
+
+def run_stage_extract(settings: ExtractSettings) -> None:
+    dataset = load_dataset(
+        settings.dataset_name,
+        settings.dataset_config,
+        split=settings.dataset_split,
+        streaming=settings.stream_dataset,
+    )
+
+    settings.output_dir.mkdir(parents=True, exist_ok=True)
+
+    documents: List[DocumentMetadata] = []
+    failures: List[Dict[str, Any]] = []
+
+    chunk_size = max(settings.inference.max_batch_size, 1)
+
+    LOGGER.info(
+        "Extract stage | dataset=%s/%s/%s | max_samples=%s | chunk=%s",
+        settings.dataset_name,
+        settings.dataset_config,
+        settings.dataset_split,
+        settings.max_samples,
+        chunk_size,
+    )
+
+    batch_contexts: List[Dict[str, Any]] = []
+    batch_requests: List[Dict[str, Any]] = []
+
+    def flush_batch() -> None:
+        nonlocal batch_contexts, batch_requests
+        if not batch_contexts:
+            return
+
+        try:
+            responses = list(settings.client.infer_batch(batch_requests))
+        except Exception as exc:  # pragma: no cover - defensive logging
+            LOGGER.exception("Batch inference failed for %s samples", len(batch_contexts))
+            for ctx in batch_contexts:
+                failures.append(
+                    {
+                        "sample_id": ctx["sample_id"],
+                        "dataset_index": ctx["dataset_index"],
+                        "error": str(exc),
+                        "exception_type": exc.__class__.__name__,
+                    }
+                )
+                image_obj = ctx.get("image")
+                if hasattr(image_obj, "close"):
+                    image_obj.close()
+            batch_contexts = []
+            batch_requests = []
+            return
+
+        if len(responses) != len(batch_contexts):
+            LOGGER.warning(
+                "Mismatch between responses (%s) and requests (%s) in extract batch",
+                len(responses),
+                len(batch_contexts),
+            )
+
+        for idx, ctx in enumerate(batch_contexts):
+            image_obj = ctx.get("image")
+            try:
+                response_text = responses[idx].strip() if idx < len(responses) else ""
+                if not response_text:
+                    raise RuntimeError("Empty response from DeepSeek inference")
+
+                raw_response_path = ctx["sample_dir"] / "raw_response.md"
+                write_text(raw_response_path, response_text)
+
+                markdown, figures = build_document_markdown(
+                    image=image_obj,
+                    response_text=response_text,
+                    sample_dir=ctx["sample_dir"],
+                    sample_id=ctx["sample_id"],
+                )
+
+                document_path = ctx["sample_dir"] / "document.md"
+                write_text(document_path, markdown)
+
+                documents.append(
+                    DocumentMetadata(
+                        sample_id=ctx["sample_id"],
+                        dataset_index=ctx["dataset_index"],
+                        document_path=(Path(ctx["sample_id"]) / "document.md").as_posix(),
+                        raw_response_path=(Path(ctx["sample_id"]) / "raw_response.md").as_posix(),
+                        source_image_path=(Path(ctx["sample_id"]) / "source.png").as_posix(),
+                        figures=figures,
+                    )
+                )
+
+                LOGGER.debug(
+                    "Processed sample %s | figures=%s | markdown_chars=%s",
+                    ctx["sample_id"],
+                    len(figures),
+                    len(markdown),
+                )
+            except Exception as exc:  # pragma: no cover - defensive logging
+                LOGGER.exception("Failed to finalize sample %s", ctx["sample_id"])
+                failures.append(
+                    {
+                        "sample_id": ctx["sample_id"],
+                        "dataset_index": ctx["dataset_index"],
+                        "error": str(exc),
+                        "exception_type": exc.__class__.__name__,
+                    }
+                )
+            finally:
+                if hasattr(image_obj, "close"):
+                    image_obj.close()
+
+        batch_contexts = []
+        batch_requests = []
+
+    for idx, sample in enumerate(dataset):
+        if settings.max_samples is not None and idx >= settings.max_samples:
+            break
+
+        sample_id = f"sample_{idx:05d}"
+        sample_dir = settings.output_dir / sample_id
+        sample_dir.mkdir(parents=True, exist_ok=True)
+
+        image = sample["images"][0]
+        if not isinstance(image, Image.Image):
+            image = Image.fromarray(image)
+        image = image.convert("RGB")
+
+        source_image_path = sample_dir / "source.png"
+        image.save(source_image_path)
+
+        batch_contexts.append(
+            {
+                "sample_id": sample_id,
+                "dataset_index": idx,
+                "sample_dir": sample_dir,
+                "image": image,
+            }
+        )
+        batch_requests.append(
+            {
+                "image": image,
+                "prompt": settings.prompt,
+                "max_tokens": settings.max_tokens,
+                "temperature": settings.temperature,
+                "request_timeout": settings.inference.request_timeout,
+            }
+        )
+
+        if len(batch_requests) >= chunk_size:
+            flush_batch()
+
+    flush_batch()
+
+    manifest = {
+        "generated_at": __now_iso(),
+        "stage": "extract",
+        "dataset": {
+            "name": settings.dataset_name,
+            "config": settings.dataset_config,
+            "split": settings.dataset_split,
+        },
+        "model": {
+            "served_model_name": settings.served_model_name,
+            "prompt": settings.prompt,
+            "max_tokens": settings.max_tokens,
+            "temperature": settings.temperature,
+        },
+        "inference": {
+            "max_batch_size": settings.inference.max_batch_size,
+            "max_concurrency": settings.inference.max_concurrency,
+            "request_timeout": settings.inference.request_timeout,
+            "max_retries": settings.inference.max_retries,
+            "retry_backoff_seconds": settings.inference.retry_backoff_seconds,
+            "max_retry_wait_seconds": settings.inference.max_retry_wait_seconds,
+        },
+        "documents": [dataclass_to_dict(document) for document in documents],
+        "failures": failures,
+    }
+
+    write_json(settings.output_dir / "manifest.json", manifest)
+    LOGGER.info(
+        "Extract stage complete | documents=%s | failures=%s",
+        len(documents),
+        len(failures),
+    )
+
+
+def run_stage_describe(settings: DescribeSettings) -> None:
+    stage1_dir = resolve_stage_dir(settings.stage1_dir, settings.source_locator)
+
+    manifest_name = settings.source_locator.manifest_name or "manifest.json"
+    manifest_path = stage1_dir / manifest_name
+    if not manifest_path.exists():
+        raise FileNotFoundError(f"Stage 1 manifest not found at {manifest_path}")
+
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    documents = manifest.get("documents", [])
+
+    settings.output_dir.mkdir(parents=True, exist_ok=True)
+
+    sample_to_figures: Dict[str, List[Dict[str, Any]]] = {}
+    all_figures: List[Dict[str, Any]] = []
+    failures: List[Dict[str, Any]] = []
+
+    chunk_size = max(settings.inference.max_batch_size, 1)
+    total_figures = sum(len(doc.get("figures", [])) for doc in documents)
+
+    LOGGER.info(
+        "Describe stage | documents=%s | figures=%s | chunk=%s",
+        len(documents),
+        total_figures,
+        chunk_size,
+    )
+
+    batch_contexts: List[Dict[str, Any]] = []
+    batch_requests: List[Dict[str, Any]] = []
+
+    def flush_batch() -> None:
+        nonlocal batch_contexts, batch_requests
+        if not batch_contexts:
+            return
+
+        try:
+            responses = list(settings.client.infer_batch(batch_requests))
+        except Exception as exc:  # pragma: no cover - defensive logging
+            LOGGER.exception("Describe batch inference failed for %s figures", len(batch_contexts))
+            for ctx in batch_contexts:
+                failures.append(
+                    {
+                        "sample_id": ctx["sample_id"],
+                        "dataset_index": ctx["dataset_index"],
+                        "figure_id": ctx["figure_id"],
+                        "image_path": ctx["image_rel_path"],
+                        "error": str(exc),
+                        "exception_type": exc.__class__.__name__,
+                    }
+                )
+                image_obj = ctx.get("image")
+                if hasattr(image_obj, "close"):
+                    image_obj.close()
+            batch_contexts = []
+            batch_requests = []
+            return
+
+        if len(responses) != len(batch_contexts):
+            LOGGER.warning(
+                "Mismatch between responses (%s) and requests (%s) in describe batch",
+                len(responses),
+                len(batch_contexts),
+            )
+
+        for idx, ctx in enumerate(batch_contexts):
+            image_obj = ctx.get("image")
+            try:
+                description = responses[idx].strip() if idx < len(responses) else ""
+                if not description:
+                    raise RuntimeError("Empty description generated for figure")
+
+                record = {
+                    "figure_id": ctx["figure_id"],
+                    "sample_id": ctx["sample_id"],
+                    "dataset_index": ctx["dataset_index"],
+                    "image_path": ctx["image_rel_path"],
+                    "document_relative_path": ctx["document_relative_path"],
+                    "description": description,
+                }
+                sample_to_figures.setdefault(ctx["sample_id"], []).append(record)
+                all_figures.append(record)
+
+                LOGGER.debug(
+                    "Described figure %s | description_chars=%s",
+                    ctx["figure_id"],
+                    len(description),
+                )
+            except Exception as exc:  # pragma: no cover - defensive logging
+                LOGGER.exception("Failed to finalize description for figure %s", ctx["figure_id"])
+                failures.append(
+                    {
+                        "sample_id": ctx["sample_id"],
+                        "dataset_index": ctx["dataset_index"],
+                        "figure_id": ctx["figure_id"],
+                        "image_path": ctx["image_rel_path"],
+                        "error": str(exc),
+                        "exception_type": exc.__class__.__name__,
+                    }
+                )
+            finally:
+                if hasattr(image_obj, "close"):
+                    image_obj.close()
+
+        batch_contexts = []
+        batch_requests = []
+
+    for document in documents:
+        sample_id = document["sample_id"]
+        dataset_index = document.get("dataset_index")
+        for figure in document.get("figures", []):
+            image_rel_path = figure["image_path"]
+            image_path = stage1_dir / image_rel_path
+            if not image_path.exists():
+                LOGGER.warning("Figure image missing: %s", image_path)
+                failures.append(
+                    {
+                        "sample_id": sample_id,
+                        "dataset_index": dataset_index,
+                        "figure_id": figure["figure_id"],
+                        "image_path": image_rel_path,
+                        "reason": "missing_image",
+                    }
+                )
+                continue
+
+            try:
+                figure_image = Image.open(image_path).convert("RGB")
+            except Exception as exc:  # pragma: no cover - defensive logging
+                LOGGER.exception("Failed to load figure image %s", image_path)
+                failures.append(
+                    {
+                        "sample_id": sample_id,
+                        "dataset_index": dataset_index,
+                        "figure_id": figure["figure_id"],
+                        "image_path": image_rel_path,
+                        "error": str(exc),
+                        "exception_type": exc.__class__.__name__,
+                    }
+                )
+                continue
+
+            batch_contexts.append(
+                {
+                    "sample_id": sample_id,
+                    "dataset_index": dataset_index,
+                    "figure_id": figure["figure_id"],
+                    "image_rel_path": image_rel_path,
+                    "document_relative_path": figure.get("document_relative_path"),
+                    "image": figure_image,
+                }
+            )
+            batch_requests.append(
+                {
+                    "image": figure_image,
+                    "prompt": settings.prompt,
+                    "max_tokens": settings.max_tokens,
+                    "temperature": settings.temperature,
+                    "request_timeout": settings.inference.request_timeout,
+                }
+            )
+
+            if len(batch_requests) >= chunk_size:
+                flush_batch()
+
+    flush_batch()
+
+    for sample_id, records in sample_to_figures.items():
+        records.sort(key=lambda entry: entry["figure_id"])
+        write_json(
+            settings.output_dir / f"{sample_id}.json",
+            {"sample_id": sample_id, "figures": records},
+        )
+
+    aggregate = {
+        "generated_at": __now_iso(),
+        "stage": "describe",
+        "prompt": settings.prompt,
+        "max_tokens": settings.max_tokens,
+        "temperature": settings.temperature,
+        "inference": {
+            "max_batch_size": settings.inference.max_batch_size,
+            "max_concurrency": settings.inference.max_concurrency,
+            "request_timeout": settings.inference.request_timeout,
+            "max_retries": settings.inference.max_retries,
+            "retry_backoff_seconds": settings.inference.retry_backoff_seconds,
+            "max_retry_wait_seconds": settings.inference.max_retry_wait_seconds,
+        },
+        "figures": all_figures,
+        "failures": failures,
+    }
+    write_json(settings.output_dir / "figure_descriptions.json", aggregate)
+    LOGGER.info(
+        "Describe stage complete | figures=%s | failures=%s",
+        len(all_figures),
+        len(failures),
+    )
+
+
+def run_stage_assemble(settings: AssembleSettings) -> None:
+    stage1_dir = resolve_stage_dir(settings.stage1_dir, settings.stage1_locator)
+    stage2_dir = resolve_stage_dir(settings.stage2_dir, settings.stage2_locator)
+
+    manifest_name = settings.stage1_locator.manifest_name or "manifest.json"
+    manifest_path = stage1_dir / manifest_name
+    if not manifest_path.exists():
+        raise FileNotFoundError(f"Stage 1 manifest not found at {manifest_path}")
+
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    documents = manifest.get("documents", [])
+
+    description_map = _load_figure_descriptions(stage2_dir)
+    settings.output_dir.mkdir(parents=True, exist_ok=True)
+
+    final_documents: List[Dict[str, Any]] = []
+    dataset_records: List[Dict[str, Any]] = []
+    failures: List[Dict[str, Any]] = []
+
+    LOGGER.info(
+        "Starting assemble stage | documents=%s | figures_with_descriptions=%s",
+        len(documents),
+        len(description_map),
+    )
+
+    for document in documents:
+        sample_id = document["sample_id"]
+        sample_output_dir = settings.output_dir / sample_id
+        sample_output_dir.mkdir(parents=True, exist_ok=True)
+
+        doc_rel_path = Path(document["document_path"])
+        stage1_doc_path = stage1_dir / doc_rel_path
+        if not stage1_doc_path.exists():
+            LOGGER.warning("Document markdown missing: %s", stage1_doc_path)
+            failures.append(
+                {
+                    "sample_id": sample_id,
+                    "dataset_index": document.get("dataset_index"),
+                    "missing_path": stage1_doc_path.as_posix(),
+                    "reason": "document_missing",
+                }
+            )
+            continue
+
+        markdown = stage1_doc_path.read_text(encoding="utf-8")
+        enriched_markdown = enrich_markdown_with_captions(markdown, description_map)
+
+        final_doc_path = sample_output_dir / "document_final.md"
+        write_text(final_doc_path, enriched_markdown)
+
+        copied_figures: List[Dict[str, Any]] = []
+        for figure in document.get("figures", []):
+            figure_id = figure["figure_id"]
+            source_fig_path = stage1_dir / figure["image_path"]
+            if not source_fig_path.exists():
+                LOGGER.warning("Figure image missing: %s", source_fig_path)
+                failures.append(
+                    {
+                        "sample_id": sample_id,
+                        "figure_id": figure_id,
+                        "missing_path": source_fig_path.as_posix(),
+                        "reason": "figure_missing",
+                    }
+                )
+                continue
+
+            target_fig_dir = sample_output_dir / "figures"
+            target_fig_dir.mkdir(parents=True, exist_ok=True)
+            target_fig_path = target_fig_dir / Path(figure["document_relative_path"]).name
+            shutil.copy2(source_fig_path, target_fig_path)
+
+            description_entry = description_map.get(figure_id, {})
+            if not description_entry:
+                failures.append(
+                    {
+                        "sample_id": sample_id,
+                        "figure_id": figure_id,
+                        "reason": "description_missing",
+                    }
+                )
+            copied_figures.append(
+                {
+                    "figure_id": figure_id,
+                    "image_path": (
+                        Path(sample_id) / "figures" / target_fig_path.name
+                    ).as_posix(),
+                    "description": description_entry.get("description"),
+                }
+            )
+
+        final_doc_rel_path = (Path(sample_id) / "document_final.md").as_posix()
+        final_documents.append(
+            {
+                "sample_id": sample_id,
+                "dataset_index": document.get("dataset_index"),
+                "final_document_path": final_doc_rel_path,
+                "figures": copied_figures,
+            }
+        )
+
+        dataset_records.append(
+            {
+                "sample_id": sample_id,
+                "dataset_index": document.get("dataset_index"),
+                "document_markdown": final_doc_rel_path,
+                "figures": copied_figures,
+            }
+        )
+
+    aggregate = {
+        "generated_at": __now_iso(),
+        "stage": "assemble",
+        "documents": final_documents,
+        "source_manifest": manifest_path.relative_to(stage1_dir).as_posix(),
+        "failures": failures,
+    }
+    write_json(settings.output_dir / "manifest.json", aggregate)
+    write_jsonl(settings.output_dir / "dataset.jsonl", dataset_records)
+
+    maybe_upload_dataset(
+        output_dir=settings.output_dir,
+        repo_id=settings.dataset_repo_id,
+        repo_type=settings.dataset_repo_type,
+        path_in_repo=settings.dataset_path_in_repo,
+        commit_message=settings.dataset_commit_message,
+        revision=settings.dataset_branch,
+    )
+    LOGGER.info(
+        "Assemble stage complete | documents=%s | failures=%s",
+        len(final_documents),
+        len(failures),
+    )
+
+
+def _load_figure_descriptions(stage2_dir: Path) -> Dict[str, Dict[str, Any]]:
+    aggregate_path = stage2_dir / "figure_descriptions.json"
+    descriptions: Dict[str, Dict[str, Any]] = {}
+    if aggregate_path.exists():
+        data = json.loads(aggregate_path.read_text(encoding="utf-8"))
+        for entry in data.get("figures", []):
+            descriptions[entry["figure_id"]] = entry
+        return descriptions
+
+    for json_file in stage2_dir.glob("*.json"):
+        data = json.loads(json_file.read_text(encoding="utf-8"))
+        for entry in data.get("figures", []):
+            descriptions[entry["figure_id"]] = entry
+    return descriptions
+
+
+def dataclass_to_dict(document: DocumentMetadata) -> Dict[str, Any]:
+    result = {
+        "sample_id": document.sample_id,
+        "dataset_index": document.dataset_index,
+        "document_path": document.document_path,
+        "raw_response_path": document.raw_response_path,
+        "source_image_path": document.source_image_path,
+        "figures": [
+            {
+                "figure_id": figure.figure_id,
+                "label": figure.label,
+                "image_path": figure.image_path,
+                "document_relative_path": figure.document_relative_path,
+                "bounding_box_norm": figure.bounding_box_norm,
+                "bounding_box_norm_list": figure.bounding_box_norm_list,
+                "bounding_box_pixels": figure.bounding_box_pixels,
+                "description": figure.description,
+            }
+            for figure in document.figures
+        ],
+    }
+    return result
+
+
+def __now_iso() -> str:
+    from datetime import datetime
+
+    return datetime.utcnow().isoformat() + "Z"
+
+__all__ = [
+    "run_stage_extract",
+    "run_stage_describe",
+    "run_stage_assemble",
+]
+

hf_job_runner.py

@@ -0,0 +1,57 @@
+"""
+Minimal entrypoint for Hugging Face Jobs.
+
+It downloads the job code repository (containing the `ds_batch_ocr` package)
+using `huggingface_hub.snapshot_download` and then delegates to
+`ds_batch_ocr.cli.main`.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+def ensure_code_checkout() -> Path:
+    repo_id = os.environ.get("JOB_CODE_REPO")
+    if not repo_id:
+        raise RuntimeError("JOB_CODE_REPO environment variable must be set.")
+
+    repo_type = os.environ.get("JOB_CODE_REPO_TYPE", "dataset")
+    revision = os.environ.get("JOB_CODE_REVISION")
+    local_dir = Path(os.environ.get("JOB_CODE_LOCAL_DIR", "/tmp/deepseek-ocr-job-code"))
+    local_dir.mkdir(parents=True, exist_ok=True)
+
+    try:
+        from huggingface_hub import snapshot_download
+    except ModuleNotFoundError:
+        subprocess.run(
+            [sys.executable, "-m", "pip", "install", "huggingface_hub"],
+            check=True,
+        )
+        from huggingface_hub import snapshot_download
+
+    snapshot_download(
+        repo_id=repo_id,
+        repo_type=repo_type,
+        revision=revision,
+        local_dir=str(local_dir),
+        local_dir_use_symlinks=False,
+    )
+    return local_dir
+
+
+def main() -> None:
+    code_dir = ensure_code_checkout()
+    sys.path.insert(0, str(code_dir))
+
+    from ds_batch_ocr.cli import main as pipeline_main
+
+    pipeline_main()
+
+
+if __name__ == "__main__":
+    main()
+