Upload folder using huggingface_hub

llm_ocr/__init__.py

@@ -13,27 +13,27 @@ Example usage:
 
 # Stage runners - main entry points for pipeline stages
 from llm_ocr.stages import (
-    run_stage_assemble,
-    run_stage_describe,
-    run_stage_extract,
+    run_stage_assemble as run_stage_assemble,
+    run_stage_describe as run_stage_describe,
+    run_stage_extract as run_stage_extract,
 )
 
 # Configuration classes
 from llm_ocr.config import (
-    AssembleSettings,
-    DescribeSettings,
-    ExtractSettings,
-    InferenceSettings,
+    AssembleSettings as AssembleSettings,
+    DescribeSettings as DescribeSettings,
+    ExtractSettings as ExtractSettings,
+    InferenceSettings as InferenceSettings,
 )
 
 # Inference client
-from llm_ocr.server import DeepSeekClient
+from llm_ocr.server import DeepSeekClient as DeepSeekClient
 
 # Storage backends
 from llm_ocr.storage import (
-    DatasetStorage,
-    GCSStorage,
-    HFHubStorage,
-    S3Storage,
-    get_storage,
+    DatasetStorage as DatasetStorage,
+    GCSStorage as GCSStorage,
+    HFHubStorage as HFHubStorage,
+    S3Storage as S3Storage,
+    get_storage as get_storage,
 )

llm_ocr/cli.py

@@ -1,11 +1,18 @@
 """CLI entrypoint for the DeepSeek OCR pipeline."""
+
 from __future__ import annotations
 
 import logging
-import os
 
 from .config import AssembleSettings, DescribeSettings, ExtractSettings, env
-from .server import DeepSeekClient, base_url_from_env, launch_vllm, should_launch_server, shutdown_server, wait_for_server
+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__)
@@ -17,14 +24,27 @@ def _setup_logging() -> None:
     try:
         from rich.console import Console
         from rich.logging import RichHandler
-        console = Console(force_terminal=env("FORCE_COLOR", "").lower() in {"1", "true"})
-        handler = RichHandler(console=console, show_time=True, show_level=True, rich_tracebacks=True)
-        logging.basicConfig(level=level, format="%(message)s", handlers=[handler], force=True)
+
+        console = Console(
+            force_terminal=env("FORCE_COLOR", "").lower() in {"1", "true"}
+        )
+        handler = RichHandler(
+            console=console, show_time=True, show_level=True, rich_tracebacks=True
+        )
+        logging.basicConfig(
+            level=level, format="%(message)s", handlers=[handler], force=True
+        )
     except ImportError:
-        logging.basicConfig(level=level, format="%(asctime)s | %(levelname)s | %(name)s | %(message)s", force=True)
+        logging.basicConfig(
+            level=level,
+            format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+            force=True,
+        )
 
 
-def _create_client(max_tokens: int, temperature: float, inference_settings) -> DeepSeekClient:
+def _create_client(
+    max_tokens: int, temperature: float, inference_settings
+) -> DeepSeekClient:
     """Create DeepSeek client from environment."""
     return DeepSeekClient(
         base_url=base_url_from_env(),
@@ -62,6 +82,7 @@ def main() -> None:
 
         if stage == "extract":
             from .config import InferenceSettings
+
             inference = InferenceSettings.from_env("EXTRACT")
             max_tokens = env("DOC_MAX_TOKENS", 2048, int)
             temperature = env("DOC_TEMPERATURE", 0.0, float)
@@ -72,6 +93,7 @@ def main() -> None:
 
         elif stage == "describe":
             from .config import InferenceSettings
+
             inference = InferenceSettings.from_env("DESCRIBE")
             max_tokens = env("FIGURE_MAX_TOKENS", 512, int)
             temperature = env("FIGURE_TEMPERATURE", 0.0, float)

llm_ocr/cloudrun_io.py

@@ -1,4 +1,5 @@
 """Google Cloud Storage utilities for Cloud Run jobs."""
+
 from __future__ import annotations
 
 import logging
@@ -15,6 +16,7 @@ LOGGER = logging.getLogger(__name__)
 def get_gcs_client():
     """Get GCS client."""
     from google.cloud import storage
+
     return storage.Client()
 
 
@@ -34,34 +36,34 @@ def upload_files_to_gcs(
     gcs_uri: str,
     path_prefix: str = "",
 ) -> None:
-    """Upload local files to GCS.
-    
-    Args:
-        output_dir: Local directory containing files to upload
-        gcs_uri: GCS URI (gs://bucket/prefix)
-        path_prefix: Additional prefix to add to GCS keys
-    """
+    """Upload local directory contents to GCS."""
     if not gcs_uri:
         LOGGER.info("No GCS URI provided; skipping upload.")
         return
 
     bucket_name, base_prefix = parse_gcs_uri(gcs_uri)
-    
+
     full_prefix = base_prefix.rstrip("/")
     if path_prefix:
-        full_prefix = f"{full_prefix}/{path_prefix.strip('/')}" if full_prefix else path_prefix.strip("/")
+        full_prefix = (
+            f"{full_prefix}/{path_prefix.strip('/')}"
+            if full_prefix
+            else path_prefix.strip("/")
+        )
 
     client = get_gcs_client()
     bucket = client.bucket(bucket_name)
     base = output_dir.resolve()
-    
+
     files = sorted(p for p in base.rglob("*") if p.is_file())
     if not files:
         LOGGER.info("Nothing to upload from %s", output_dir)
         return
 
-    LOGGER.info("Uploading %d files to gs://%s/%s", len(files), bucket_name, full_prefix)
-    
+    LOGGER.info(
+        "Uploading %d files to gs://%s/%s", len(files), bucket_name, full_prefix
+    )
+
     for local_path in files:
         rel = local_path.relative_to(base).as_posix()
         gcs_key = f"{full_prefix}/{rel}" if full_prefix else rel
@@ -69,7 +71,13 @@ def upload_files_to_gcs(
             blob = bucket.blob(gcs_key)
             blob.upload_from_filename(str(local_path))
         except Exception as exc:
-            LOGGER.error("Failed to upload %s to gs://%s/%s: %s", local_path, bucket_name, gcs_key, exc)
+            LOGGER.error(
+                "Failed to upload %s to gs://%s/%s: %s",
+                local_path,
+                bucket_name,
+                gcs_key,
+                exc,
+            )
             raise
 
 
@@ -78,18 +86,9 @@ def save_dataset_to_gcs(
     gcs_uri: str,
     name: str = "dataset",
 ) -> str:
-    """Save HF dataset to GCS using Arrow format (preserves Image columns).
-    
-    Args:
-        dataset: HuggingFace Dataset or DatasetDict to save
-        gcs_uri: Base GCS URI (gs://bucket/prefix)
-        name: Name for the dataset folder
-        
-    Returns:
-        GCS URI of the saved dataset
-    """
+    """Save HF dataset to GCS in Arrow format. Returns the GCS URI."""
     from datasets import DatasetDict
-    
+
     # Handle DatasetDict by extracting the first split
     if isinstance(dataset, DatasetDict):
         if "train" in dataset:
@@ -98,84 +97,57 @@ def save_dataset_to_gcs(
             split_name = list(dataset.keys())[0]
             dataset = dataset[split_name]
             LOGGER.info("Using split '%s' from DatasetDict", split_name)
-    
+
     bucket_name, prefix = parse_gcs_uri(gcs_uri)
     full_prefix = prefix.rstrip("/")
-    
+
     # Save to local temp directory using Arrow format
     local_dir = Path(f"/tmp/{name}_arrow_temp")
     if local_dir.exists():
         shutil.rmtree(local_dir)
-    
+
     LOGGER.info("Saving dataset to Arrow format...")
     dataset.save_to_disk(str(local_dir))
-    
+
     # Upload entire directory to GCS
     gcs_prefix = f"{full_prefix}/{name}" if full_prefix else name
-    upload_files_to_gcs(output_dir=local_dir, gcs_uri=f"gs://{bucket_name}/{gcs_prefix}")
-    
+    upload_files_to_gcs(
+        output_dir=local_dir, gcs_uri=f"gs://{bucket_name}/{gcs_prefix}"
+    )
+
     # Cleanup
     shutil.rmtree(local_dir)
-    
+
     result_uri = f"gs://{bucket_name}/{gcs_prefix}"
     LOGGER.info("Saved dataset to %s", result_uri)
     return result_uri
 
 
-def get_dataset_features():
-    """Get the dataset feature schema."""
-    from datasets import Features, Sequence, Value, Image as HfImage
-    
-    return Features({
-        "sample_id": Value("string"),
-        "dataset_index": Value("int64"),
-        "source_image": HfImage(),
-        "document_with_boxes_image": HfImage(),
-        "document_markdown": Value("string"),
-        "extracted_figures": Sequence(HfImage()),
-        "extracted_figures_metadata": Sequence(Value("string")),
-        "document_final_markdown": Value("string"),
-    })
-
-
 def load_dataset_from_gcs(gcs_uri: str, split: str = "train") -> "Dataset":
-    """Load HF dataset directly from GCS (saved with save_to_disk).
-    
-    Downloads files locally first to avoid gcsfs caching issues.
-    
-    Args:
-        gcs_uri: GCS URI to dataset directory (gs://bucket/path/to/dataset/)
-        split: Unused, kept for API compatibility
-        
-    Returns:
-        Loaded Dataset
-        
-    Requires:
-        pip install datasets google-cloud-storage
-    """
+    """Load HF dataset from GCS. Downloads locally to avoid gcsfs caching issues."""
     from datasets import load_from_disk
     import tempfile
-    
+
     LOGGER.info("Loading dataset from %s", gcs_uri)
-    
+
     # Parse GCS URI
     bucket_name, prefix = parse_gcs_uri(gcs_uri)
-    
+
     # Download to local temp directory (bypasses gcsfs cache)
     client = get_gcs_client()
     bucket = client.bucket(bucket_name)
     local_dir = tempfile.mkdtemp(prefix="gcs_dataset_")
-    
+
     blobs = list(bucket.list_blobs(prefix=f"{prefix}/"))
     for blob in blobs:
-        filename = blob.name.split('/')[-1]
+        filename = blob.name.split("/")[-1]
         if filename:  # Skip directory markers
             local_path = f"{local_dir}/{filename}"
             blob.download_to_filename(local_path)
-    
+
     LOGGER.info("Downloaded %d files to %s", len(blobs), local_dir)
-    
+
     # Load from local
     ds = load_from_disk(local_dir)
-    
+
     return ds

llm_ocr/config.py

@@ -1,4 +1,5 @@
 """Configuration dataclasses for pipeline stages."""
+
 from __future__ import annotations
 
 import logging
@@ -27,6 +28,7 @@ def env(key: str, default: T = None, cast: Type[T] = str) -> T:
 @dataclass
 class FigureMetadata:
     """Metadata for an extracted figure (image stored in dataset, not as file)."""
+
     figure_id: str
     label: str
     bounding_box_pixels: Dict[str, int]
@@ -36,6 +38,7 @@ class FigureMetadata:
 @dataclass
 class InferenceSettings:
     """Settings for batch inference."""
+
     batch_size: int = 4
     max_concurrency: int = 4
     request_timeout: int = 120
@@ -58,6 +61,7 @@ class InferenceSettings:
 @dataclass
 class HubSettings:
     """Settings for HuggingFace Hub upload."""
+
     repo_id: Optional[str] = None
     path_in_repo: str = ""
     branch: Optional[str] = None
@@ -78,6 +82,7 @@ class HubSettings:
 @dataclass
 class ExtractSettings:
     """Settings for the extract stage."""
+
     dataset_name: str
     dataset_config: str
     dataset_split: str
@@ -100,7 +105,9 @@ class ExtractSettings:
             dataset_split=env("DATASET_SPLIT", "train"),
             output_dir=Path(env("OUTPUT_DIR", "./outputs/extract")),
             client=client,
-            prompt=env("DOC_PROMPT", "<image>\n<|grounding|>Convert this document to Markdown."),
+            prompt=env(
+                "DOC_PROMPT", "<image>\n<|grounding|>Convert this document to Markdown."
+            ),
             max_tokens=env("DOC_MAX_TOKENS", 2048, int),
             temperature=env("DOC_TEMPERATURE", 0.0, float),
             max_samples=env("MAX_SAMPLES", None, int),
@@ -113,6 +120,7 @@ class ExtractSettings:
 @dataclass
 class DescribeSettings:
     """Settings for the describe stage."""
+
     output_dir: Path
     client: Any  # DeepSeekClient
     source_repo_id: Optional[str] = None
@@ -140,6 +148,7 @@ class DescribeSettings:
 @dataclass
 class AssembleSettings:
     """Settings for the assemble stage."""
+
     source_repo_id: Optional[str] = None
     hub: HubSettings = field(default_factory=HubSettings)
 

llm_ocr/document.py

@@ -1,4 +1,5 @@
 """Document processing: markdown extraction, figure handling, and caption enrichment."""
+
 from __future__ import annotations
 
 import ast
@@ -47,12 +48,14 @@ def extract_grounding_blocks(text: str) -> List[Dict[str, Any]]:
                 coordinates = ast.literal_eval(coords_text)
             except Exception:
                 coordinates = None
-        matches.append({
-            "label": label,
-            "coordinates": coordinates,
-            "raw": match.group(0),
-            "span": match.span(),
-        })
+        matches.append(
+            {
+                "label": label,
+                "coordinates": coordinates,
+                "raw": match.group(0),
+                "span": match.span(),
+            }
+        )
     return matches
 
 
@@ -89,10 +92,13 @@ def crop_figure(
     pixel_box: List[int],
     label: str,
 ) -> Tuple[FigureMetadata, Image.Image]:
-    """Crop a figure from the source image.
-    
+    """Crop a figure region from the source image.
+
+    Args:
+        pixel_box: [x1, y1, x2, y2] bounding box in pixels
+
     Returns:
-        Tuple of (metadata, cropped_image) - image is for embedding in dataset
+        (metadata, cropped_image) tuple for embedding in dataset
     """
     x1, y1, x2, y2 = pixel_box
     crop = image.crop((x1, y1, x2, y2)).copy()
@@ -104,7 +110,7 @@ def crop_figure(
         label=label,
         bounding_box_pixels={"x1": x1, "y1": y1, "x2": x2, "y2": y2},
     )
-    
+
     return metadata, crop
 
 
@@ -126,14 +132,10 @@ def build_document_markdown(
     response_text: str,
     sample_id: str,
 ) -> Tuple[str, List[FigureMetadata], List[Image.Image], Image.Image]:
-    """
-    Process model response to extract markdown and figures.
-    
+    """Process model response to extract markdown and figures.
+
     Returns:
-        - Cleaned markdown with figure references (using figure:{id} URIs)
-        - List of figure metadata
-        - List of cropped figure images (for embedding in dataset)
-        - Annotated image with bounding boxes
+        (markdown, figure_metadata, figure_images, annotated_image) tuple
     """
     blocks = extract_grounding_blocks(response_text)
     replacements: List[Tuple[int, int, str]] = []
@@ -154,7 +156,11 @@ def build_document_markdown(
         start, end = block["span"]
 
         # Random color for this block
-        color = (np.random.randint(0, 200), np.random.randint(0, 200), np.random.randint(0, 255))
+        color = (
+            np.random.randint(0, 200),
+            np.random.randint(0, 200),
+            np.random.randint(0, 255),
+        )
         color_alpha = color + (20,)
 
         # Convert normalized coords to pixels
@@ -177,10 +183,13 @@ def build_document_markdown(
             figures.append(metadata)
             figure_images.append(crop)
             # Use figure:{id} URI format - clearly an identifier, not a file path
-            replacements.append((
-                start, end,
-                f"![{metadata.figure_id}](figure:{metadata.figure_id})",
-            ))
+            replacements.append(
+                (
+                    start,
+                    end,
+                    f"![{metadata.figure_id}](figure:{metadata.figure_id})",
+                )
+            )
             figure_index += 1
         else:
             replacements.append((start, end, ""))
@@ -194,7 +203,9 @@ def build_document_markdown(
         text_x, text_y = x1, max(0, y1 - 15)
         text_bbox = draw.textbbox((0, 0), label, font=font)
         text_w, text_h = text_bbox[2] - text_bbox[0], text_bbox[3] - text_bbox[1]
-        draw.rectangle([text_x, text_y, text_x + text_w, text_y + text_h], fill=(255, 255, 255, 30))
+        draw.rectangle(
+            [text_x, text_y, text_x + text_w, text_y + text_h], fill=(255, 255, 255, 30)
+        )
         draw.text((text_x, text_y), label, font=font, fill=color)
 
     img_draw.paste(overlay, (0, 0), overlay)
@@ -217,27 +228,20 @@ def enrich_markdown_with_captions(
     markdown: str,
     description_map: Dict[str, Dict[str, Any]],
 ) -> str:
-    """Add figure captions to markdown based on descriptions.
-    
-    Handles both new format ![figure_id](figure:figure_id) and 
-    legacy format ![Figure figure_id](path).
-    
-    The alt text is kept short (first sentence/~120 chars) for accessibility.
-    The full description appears as an italicized caption below the image.
-    """
+    """Add figure captions to markdown. Alt text is truncated; full description below."""
     used: set[str] = set()
 
     def replace(match: re.Match[str]) -> str:
         alt_text = match.group("figure_id").strip()
         path = match.group("path").strip()
-        
+
         # Extract figure_id from figure:{id} URI or from alt text
         if path.startswith("figure:"):
             figure_id = path[7:]  # Remove "figure:" prefix
         else:
             # Legacy format - figure_id is in alt text after "Figure "
             figure_id = alt_text.replace("Figure ", "").split(":")[0].strip()
-        
+
         entry = description_map.get(figure_id)
         if not entry:
             return match.group(0)
@@ -248,10 +252,10 @@ def enrich_markdown_with_captions(
 
         # Alt text: short summary (first sentence, max 120 chars)
         short_alt = _truncate_for_alt(description)
-        
+
         # Image tag with short alt text
         rendered = f"![{figure_id}: {short_alt}]({path})"
-        
+
         # Add full caption below (only once per figure)
         if figure_id not in used:
             rendered += f"\n\n*Figure {figure_id}: {description}*\n"
@@ -266,62 +270,42 @@ def render_markdown_with_images(
     figure_images: List[Image.Image],
     figure_metadata: List[Dict[str, Any]],
 ) -> str:
-    """
-    Render markdown with embedded images as base64 data URIs.
-    
-    The dataset stores images in `extracted_figures` (PIL images) and metadata
-    in `extracted_figures_metadata` (with figure_id). This function replaces
-    figure:{id} URIs in markdown with base64-encoded images.
-    
-    Args:
-        markdown: Markdown text with ![figure_id](figure:figure_id) references
-        figure_images: List of PIL images from dataset's extracted_figures column
-        figure_metadata: List of metadata dicts (parsed from extracted_figures_metadata)
-        
-    Returns:
-        Self-contained markdown with images embedded as data URIs
-    """
+    """Replace figure:{id} URIs in markdown with base64-encoded images."""
     # Build figure_id -> image mapping
     id_to_image: Dict[str, Image.Image] = {}
     for i, meta in enumerate(figure_metadata):
         fig_id = meta.get("figure_id", "")
         if fig_id and i < len(figure_images) and figure_images[i] is not None:
             id_to_image[fig_id] = figure_images[i]
-    
+
     def replace(match: re.Match[str]) -> str:
         alt_text = match.group("figure_id").strip()
         path = match.group("path").strip()
-        
+
         # Extract figure_id from figure:{id} URI or use alt_text as fallback
         if path.startswith("figure:"):
             figure_id = path[7:]  # Remove "figure:" prefix
         else:
             # Legacy path format - extract figure_id from alt_text
             figure_id = alt_text.replace("Figure ", "").split(":")[0].strip()
-        
+
         img = id_to_image.get(figure_id)
         if img is None:
             return match.group(0)  # Keep original if image not found
-        
+
         # Embed as base64 data URI
         data_uri = f"data:image/png;base64,{encode_image(img)}"
         return f"![{alt_text}]({data_uri})"
-    
+
     return FIGURE_MARKDOWN_PATTERN.sub(replace, markdown)
 
 
 def render_sample_markdown(sample: Dict[str, Any]) -> str:
-    """
-    Render a dataset sample's markdown with embedded images.
-    
-    Args:
-        sample: A row from the dataset (dict with column values)
-        
-    Returns:
-        Self-contained markdown string with images as data URIs
-    """
-    markdown = sample.get("document_final_markdown") or sample.get("document_markdown") or ""
-    
+    """Render dataset sample's markdown with embedded base64 images."""
+    markdown = (
+        sample.get("document_final_markdown") or sample.get("document_markdown") or ""
+    )
+
     # Parse metadata
     raw_metadata = sample.get("extracted_figures_metadata") or []
     metadata = []
@@ -330,9 +314,9 @@ def render_sample_markdown(sample: Dict[str, Any]) -> str:
             metadata.append(json.loads(m))
         else:
             metadata.append(m)
-    
+
     images = sample.get("extracted_figures") or []
-    
+
     return render_markdown_with_images(
         markdown=markdown,
         figure_images=images,
@@ -341,65 +325,49 @@ def render_sample_markdown(sample: Dict[str, Any]) -> str:
 
 
 def display_markdown(sample: Dict[str, Any]) -> None:
-    """
-    Display a dataset sample's markdown with images rendered in Jupyter.
-    
-    This function takes a dataset row, renders the figure: URIs as actual
-    images (from the extracted_figures column), and displays the result
-    as formatted markdown in the notebook.
-    
-    Args:
-        sample: A row from the dataset (dict with column values)
-    """
+    """Display sample's markdown with embedded images in Jupyter."""
     from IPython.display import display, Markdown
-    
+
     rendered = render_sample_markdown(sample)
     display(Markdown(rendered))
 
 
 def display_samples(dataset, num_samples: int = 2) -> None:
-    """
-    Display a few samples from a dataset with images and figure descriptions.
-    
-    Shows source images, markdown previews, extracted figures with their
-    descriptions from metadata.
-    
-    Args:
-        dataset: A Hugging Face dataset or list of samples
-        num_samples: Number of samples to display (default 2)
-    """
+    """Display samples with source images, markdown, and figure descriptions."""
     from IPython.display import display
-    
+
     print(f"Dataset: {len(dataset)} samples")
     print(f"Columns: {list(dataset.column_names)}")
     print()
-    
+
     for i in range(min(num_samples, len(dataset))):
         sample = dataset[i]
         print(f"=== Sample {i}: {sample.get('sample_id', i)} ===")
-        
+
         # Show source image
-        if sample.get('source_image'):
+        if sample.get("source_image"):
             print("Source image:")
-            img = sample['source_image']
+            img = sample["source_image"]
             img.thumbnail((500, 500))  # Resize to max 500px
             display(img)
-        
+
         # Show markdown preview
-        md = sample.get('document_markdown') or sample.get('document_markdown_text', '')
+        md = sample.get("document_markdown") or sample.get("document_markdown_text", "")
         if md:
             print(f"\nMarkdown preview ({len(md)} chars):")
-            print(md[:500] + '...' if len(md) > 500 else md)
-        
+            print(md[:500] + "..." if len(md) > 500 else md)
+
         # Show final markdown if available
-        final_md = sample.get('document_final_markdown') or sample.get('document_final_markdown_text', '')
+        final_md = sample.get("document_final_markdown") or sample.get(
+            "document_final_markdown_text", ""
+        )
         if final_md:
             print(f"\nFinal markdown preview ({len(final_md)} chars):")
-            print(final_md[:500] + '...' if len(final_md) > 500 else final_md)
-        
+            print(final_md[:500] + "..." if len(final_md) > 500 else final_md)
+
         # Show figures and their descriptions
-        figures = sample.get('extracted_figures', [])
-        metadata = sample.get('extracted_figures_metadata', [])
+        figures = sample.get("extracted_figures", [])
+        metadata = sample.get("extracted_figures_metadata", [])
         if figures:
             print(f"\nExtracted figures: {len(figures)}")
             for j, fig in enumerate(figures[:2]):  # Show max 2 figures
@@ -408,8 +376,12 @@ def display_samples(dataset, num_samples: int = 2) -> None:
                 # Show figure description if available
                 if j < len(metadata):
                     try:
-                        meta = json.loads(metadata[j]) if isinstance(metadata[j], str) else metadata[j]
-                        if meta.get('description'):
+                        meta = (
+                            json.loads(metadata[j])
+                            if isinstance(metadata[j], str)
+                            else metadata[j]
+                        )
+                        if meta.get("description"):
                             print(f"  📝 Description: {meta['description'][:200]}...")
                     except Exception:
                         pass

llm_ocr/server.py

@@ -1,4 +1,5 @@
 """vLLM server management and async inference client."""
+
 from __future__ import annotations
 
 import asyncio
@@ -8,13 +9,16 @@ import signal
 import subprocess
 import threading
 import time
-from typing import Any, Awaitable, Dict, List, Sequence
+from typing import TYPE_CHECKING, Any, Awaitable, Dict, List, Sequence
 
 import requests
 from openai import AsyncOpenAI
 
 from .document import encode_image
 
+if TYPE_CHECKING:
+    from PIL import Image
+
 LOGGER = logging.getLogger(__name__)
 
 
@@ -35,20 +39,31 @@ def launch_vllm() -> subprocess.Popen:
     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.90"),
-        "--port", port,
-        "--host", host,
+        "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.90"),
+        "--port",
+        port,
+        "--host",
+        host,
         "--trust-remote-code",
         "--enable-chunked-prefill",
         "--no-enable-prefix-caching",
-        "--mm-processor-cache-gb", os.environ.get("MM_PROCESSOR_CACHE_GB", "0"),
-        "--logits-processors", os.environ.get(
+        "--mm-processor-cache-gb",
+        os.environ.get("MM_PROCESSOR_CACHE_GB", "0"),
+        "--logits-processors",
+        os.environ.get(
             "LOGITS_PROCESSORS",
-            "vllm.model_executor.models.deepseek_ocr:NGramPerReqLogitsProcessor"
+            "vllm.model_executor.models.deepseek_ocr:NGramPerReqLogitsProcessor",
         ),
     ]
 
@@ -57,13 +72,17 @@ def launch_vllm() -> subprocess.Popen:
         cmd.extend(extra_args.split())
 
     LOGGER.info("Launching vLLM server: %s", " ".join(cmd))
-    process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, bufsize=1)
+    process = subprocess.Popen(
+        cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, bufsize=1
+    )
 
     # Start output streaming threads
     threads = []
     for name, pipe in [("STDOUT", process.stdout), ("STDERR", process.stderr)]:
         if pipe:
-            t = threading.Thread(target=_stream_output, args=(pipe, f"vLLM {name}"), daemon=True)
+            t = threading.Thread(
+                target=_stream_output, args=(pipe, f"vLLM {name}"), daemon=True
+            )
             t.start()
             threads.append(t)
 
@@ -96,10 +115,10 @@ def wait_for_server(url: str, timeout_s: int = None, interval_s: int = 5) -> boo
     """Wait for server health endpoint to respond."""
     if timeout_s is None:
         timeout_s = int(os.environ.get("VLLM_STARTUP_TIMEOUT", "600"))  # 10 min default
-    
+
     start_time = time.time()
     LOGGER.info("⏳ Waiting for vLLM server to start...")
-    
+
     deadline = time.time() + timeout_s
     while time.time() < deadline:
         try:
@@ -110,7 +129,7 @@ def wait_for_server(url: str, timeout_s: int = None, interval_s: int = 5) -> boo
         except Exception:
             pass
         time.sleep(interval_s)
-    
+
     elapsed = time.time() - start_time
     LOGGER.error("❌ vLLM server failed to start after %s", _format_duration(elapsed))
     return False
@@ -137,25 +156,36 @@ def _prepare_payload(
     """Prepare OpenAI-compatible chat completion payload."""
     return {
         "model": model_name,
-        "messages": [{
-            "role": "user",
-            "content": [
-                {"type": "text", "text": prompt},
-                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{encode_image(image)}"}},
-            ],
-        }],
+        "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,
         "extra_body": {
             "skip_special_tokens": False,
-            "vllm_xargs": {"ngram_size": 30, "window_size": 90, "whitelist_token_ids": "[128821,128822]"},
+            "vllm_xargs": {
+                "ngram_size": 30,
+                "window_size": 90,
+                "whitelist_token_ids": "[128821,128822]",
+            },
         },
     }
 
 
 class DeepSeekClient:
     """Async batch inference client for DeepSeek OCR via vLLM."""
-    
+
     def __init__(
         self,
         base_url: str,
@@ -198,27 +228,42 @@ class DeepSeekClient:
         return getattr(response.choices[0].message, "content", "") or ""
 
     def infer(self, requests_data: Sequence[Dict[str, Any]]) -> List[str]:
-        """Run batch inference synchronously."""
+        """Run batch inference synchronously.
+
+        Args:
+            requests_data: List of dicts with keys: image (PIL.Image), prompt (str),
+                           optional: max_tokens, temperature, request_timeout
+
+        Returns:
+            List of response strings, one per request
+        """
         if not requests_data:
             return []
 
         payloads = []
         timeouts = []
         for req in requests_data:
-            payloads.append(_prepare_payload(
-                image=req["image"],
-                model_name=self.model_name,
-                prompt=req.get("prompt", ""),
-                max_tokens=req.get("max_tokens", self.default_max_tokens),
-                temperature=req.get("temperature", self.default_temperature),
-            ))
+            payloads.append(
+                _prepare_payload(
+                    image=req["image"],
+                    model_name=self.model_name,
+                    prompt=req.get("prompt", ""),
+                    max_tokens=req.get("max_tokens", self.default_max_tokens),
+                    temperature=req.get("temperature", self.default_temperature),
+                )
+            )
             timeouts.append(req.get("request_timeout") or self.default_request_timeout)
 
         return self._run_async(self._async_infer_batch(payloads, timeouts))
 
-    async def _async_infer_batch(self, payloads: Sequence[Dict[str, Any]], timeouts: Sequence[int]) -> List[str]:
+    async def _async_infer_batch(
+        self, payloads: Sequence[Dict[str, Any]], timeouts: Sequence[int]
+    ) -> List[str]:
         """Run batch of async completions concurrently."""
-        tasks = [asyncio.create_task(self._async_completion(p, t)) for p, t in zip(payloads, timeouts)]
+        tasks = [
+            asyncio.create_task(self._async_completion(p, t))
+            for p, t in zip(payloads, timeouts)
+        ]
         return await asyncio.gather(*tasks)
 
     @staticmethod

llm_ocr/sm_io.py

@@ -1,4 +1,5 @@
 """Amazon S3 utilities for SageMaker jobs."""
+
 from __future__ import annotations
 
 import logging
@@ -40,40 +41,40 @@ def upload_files_to_s3(
     s3_uri: str,
     path_prefix: str = "",
 ) -> None:
-    """Upload local files to S3.
-    
-    Args:
-        output_dir: Local directory containing files to upload
-        s3_uri: S3 URI (s3://bucket/prefix)
-        path_prefix: Additional prefix to add to S3 keys
-    """
+    """Upload local directory contents to S3."""
     if not s3_uri:
         LOGGER.info("No S3 URI provided; skipping upload.")
         return
 
     bucket, base_prefix = parse_s3_uri(s3_uri)
-    
+
     full_prefix = base_prefix.rstrip("/")
     if path_prefix:
-        full_prefix = f"{full_prefix}/{path_prefix.strip('/')}" if full_prefix else path_prefix.strip("/")
+        full_prefix = (
+            f"{full_prefix}/{path_prefix.strip('/')}"
+            if full_prefix
+            else path_prefix.strip("/")
+        )
 
     s3 = get_s3_client()
     base = output_dir.resolve()
-    
+
     files = sorted(p for p in base.rglob("*") if p.is_file())
     if not files:
         LOGGER.info("Nothing to upload from %s", output_dir)
         return
 
     LOGGER.info("Uploading %d files to s3://%s/%s", len(files), bucket, full_prefix)
-    
+
     for local_path in files:
         rel = local_path.relative_to(base).as_posix()
         s3_key = f"{full_prefix}/{rel}" if full_prefix else rel
         try:
             s3.upload_file(str(local_path), bucket, s3_key)
         except Exception as exc:
-            LOGGER.error("Failed to upload %s to s3://%s/%s: %s", local_path, bucket, s3_key, exc)
+            LOGGER.error(
+                "Failed to upload %s to s3://%s/%s: %s", local_path, bucket, s3_key, exc
+            )
             raise
 
 
@@ -82,18 +83,9 @@ def save_dataset_to_s3(
     s3_uri: str,
     name: str = "dataset",
 ) -> str:
-    """Save HF dataset to S3 using Arrow format (preserves Image columns).
-    
-    Args:
-        dataset: HuggingFace Dataset or DatasetDict to save
-        s3_uri: Base S3 URI (s3://bucket/prefix)
-        name: Name for the dataset folder
-        
-    Returns:
-        S3 URI of the saved dataset
-    """
+    """Save HF dataset to S3 in Arrow format. Returns the S3 URI."""
     from datasets import DatasetDict
-    
+
     # Handle DatasetDict by extracting the first split
     if isinstance(dataset, DatasetDict):
         if "train" in dataset:
@@ -102,88 +94,59 @@ def save_dataset_to_s3(
             split_name = list(dataset.keys())[0]
             dataset = dataset[split_name]
             LOGGER.info("Using split '%s' from DatasetDict", split_name)
-    
+
     bucket, prefix = parse_s3_uri(s3_uri)
     full_prefix = prefix.rstrip("/")
-    
+
     # Save to local temp directory using Arrow format
     local_dir = Path(f"/tmp/{name}_arrow_temp")
     if local_dir.exists():
         shutil.rmtree(local_dir)
-    
+
     LOGGER.info("Saving dataset to Arrow format...")
     dataset.save_to_disk(str(local_dir))
-    
+
     # Upload entire directory to S3
     s3_prefix = f"{full_prefix}/{name}" if full_prefix else name
     upload_files_to_s3(output_dir=local_dir, s3_uri=f"s3://{bucket}/{s3_prefix}")
-    
+
     # Cleanup
     shutil.rmtree(local_dir)
-    
+
     result_uri = f"s3://{bucket}/{s3_prefix}"
     LOGGER.info("Saved dataset to %s", result_uri)
     return result_uri
 
 
-def get_dataset_features():
-    """Get the dataset feature schema."""
-    from datasets import Features, Sequence, Value, Image as HfImage
-    
-    return Features({
-        "sample_id": Value("string"),
-        "dataset_index": Value("int64"),
-        "source_image": HfImage(),
-        "document_with_boxes_image": HfImage(),
-        "document_markdown": Value("string"),
-        "extracted_figures": Sequence(HfImage()),
-        "extracted_figures_metadata": Sequence(Value("string")),
-        "document_final_markdown": Value("string"),
-    })
-
-
 def load_dataset_from_s3(s3_uri: str, split: str = "train") -> "Dataset":
-    """Load HF dataset directly from S3 (saved with save_to_disk).
-    
-    Downloads files locally first to avoid s3fs caching issues.
-    
-    Args:
-        s3_uri: S3 URI to dataset directory (s3://bucket/path/to/dataset/)
-        split: Unused, kept for API compatibility
-        
-    Returns:
-        Loaded Dataset
-        
-    Requires:
-        pip install datasets boto3
-    """
+    """Load HF dataset from S3. Downloads locally to avoid s3fs caching issues."""
     from datasets import load_from_disk
     import tempfile
-    
+
     LOGGER.info("Loading dataset from %s", s3_uri)
-    
+
     # Parse S3 URI
     bucket_name, prefix = parse_s3_uri(s3_uri)
-    
+
     # Download to local temp directory (bypasses s3fs cache)
     s3 = get_s3_client()
     local_dir = tempfile.mkdtemp(prefix="s3_dataset_")
-    
+
     # List and download all objects
-    paginator = s3.get_paginator('list_objects_v2')
+    paginator = s3.get_paginator("list_objects_v2")
     download_count = 0
     for page in paginator.paginate(Bucket=bucket_name, Prefix=f"{prefix}/"):
-        for obj in page.get('Contents', []):
-            key = obj['Key']
-            filename = key.split('/')[-1]
+        for obj in page.get("Contents", []):
+            key = obj["Key"]
+            filename = key.split("/")[-1]
             if filename:  # Skip directory markers
                 local_path = f"{local_dir}/{filename}"
                 s3.download_file(bucket_name, key, local_path)
                 download_count += 1
-    
+
     LOGGER.info("Downloaded %d files to %s", download_count, local_dir)
-    
+
     # Load from local
     ds = load_from_disk(local_dir)
-    
+
     return ds

llm_ocr/stages.py

@@ -1,4 +1,5 @@
 """Pipeline stages: extract, describe, assemble."""
+
 from __future__ import annotations
 
 import json
@@ -7,11 +8,9 @@ import shutil
 import time
 from dataclasses import asdict
 from datetime import datetime
-from pathlib import Path
 from typing import Any, Dict, List
 
 from datasets import Features, Sequence, Value, load_dataset, Image as HfImage
-from PIL import Image
 
 from .config import AssembleSettings, DescribeSettings, ExtractSettings, env
 from .document import build_document_markdown, enrich_markdown_with_captions, write_json
@@ -33,26 +32,28 @@ def _now_iso() -> str:
 
 def _dataset_features() -> Features:
     """Dataset schema - all data is embedded, no external file paths."""
-    return Features({
-        "sample_id": Value("string"),
-        "dataset_index": Value("int64"),
-        "source_image": HfImage(),
-        "document_with_boxes_image": HfImage(),
-        "document_markdown": Value("string"),
-        "extracted_figures": Sequence(HfImage()),
-        "extracted_figures_metadata": Sequence(Value("string")),
-        "document_final_markdown": Value("string"),
-    })
+    return Features(
+        {
+            "sample_id": Value("string"),
+            "dataset_index": Value("int64"),
+            "source_image": HfImage(),
+            "document_with_boxes_image": HfImage(),
+            "document_markdown": Value("string"),
+            "extracted_figures": Sequence(HfImage()),
+            "extracted_figures_metadata": Sequence(Value("string")),
+            "document_final_markdown": Value("string"),
+        }
+    )
 
 
 def run_stage_extract(settings: ExtractSettings) -> None:
     """Run OCR extraction on dataset samples."""
     stage_start = time.time()
     LOGGER.info("⏳ Starting EXTRACT stage...")
-    
+
     # Lazy import torch - only needed for extract stage
     from torch.utils.data import DataLoader
-    
+
     dataset = load_dataset(
         settings.dataset_name,
         settings.dataset_config,
@@ -64,7 +65,11 @@ def run_stage_extract(settings: ExtractSettings) -> None:
     if settings.stream_dataset:
         num_workers = env("DATALOADER_WORKERS", 2, int)
         prefetch = env("DATALOADER_PREFETCH", 2, int)
-        kwargs = {"batch_size": 1, "num_workers": num_workers, "collate_fn": lambda b: b[0]}
+        kwargs = {
+            "batch_size": 1,
+            "num_workers": num_workers,
+            "collate_fn": lambda b: b[0],
+        }
         if num_workers > 0:
             kwargs["prefetch_factor"] = prefetch
         sample_iter = iter(DataLoader(dataset, **kwargs))
@@ -83,9 +88,14 @@ def run_stage_extract(settings: ExtractSettings) -> None:
     failures: List[Dict[str, Any]] = []
     chunk_size = settings.inference.batch_size
 
-    LOGGER.info("Extract | dataset=%s/%s/%s | max_samples=%s | batch=%s",
-                settings.dataset_name, settings.dataset_config, settings.dataset_split,
-                settings.max_samples, chunk_size)
+    LOGGER.info(
+        "Extract | dataset=%s/%s/%s | max_samples=%s | batch=%s",
+        settings.dataset_name,
+        settings.dataset_config,
+        settings.dataset_split,
+        settings.max_samples,
+        chunk_size,
+    )
 
     contexts: List[Dict[str, Any]] = []
     requests: List[Dict[str, Any]] = []
@@ -118,14 +128,16 @@ def run_stage_extract(settings: ExtractSettings) -> None:
                 sample_id = ctx["sample_id"]
 
                 markdown, figures, figure_images, img_draw = build_document_markdown(
-                    image=img, response_text=text, sample_id=sample_id,
+                    image=img,
+                    response_text=text,
+                    sample_id=sample_id,
                 )
-                
+
                 # Save images locally for dataset loading (HfImage needs file paths)
                 source_path = sample_dir / "source.png"
                 boxes_path = sample_dir / "document_with_boxes.png"
                 img_draw.save(boxes_path)
-                
+
                 # Save figure images for dataset loading
                 figures_dir = sample_dir / "figures"
                 figures_dir.mkdir(parents=True, exist_ok=True)
@@ -135,16 +147,20 @@ def run_stage_extract(settings: ExtractSettings) -> None:
                     fig_img.save(fig_path)
                     figure_paths.append(str(fig_path))
 
-                docs.append({
-                    "sample_id": sample_id,
-                    "dataset_index": ctx["dataset_index"],
-                    "source_image": str(source_path),
-                    "document_with_boxes_image": str(boxes_path),
-                    "document_markdown": markdown,
-                    "extracted_figures": figure_paths,
-                    "extracted_figures_metadata": [json.dumps(asdict(f)) for f in figures],
-                    "document_final_markdown": "",  # Filled in assemble stage
-                })
+                docs.append(
+                    {
+                        "sample_id": sample_id,
+                        "dataset_index": ctx["dataset_index"],
+                        "source_image": str(source_path),
+                        "document_with_boxes_image": str(boxes_path),
+                        "document_markdown": markdown,
+                        "extracted_figures": figure_paths,
+                        "extracted_figures_metadata": [
+                            json.dumps(asdict(f)) for f in figures
+                        ],
+                        "document_final_markdown": "",  # Filled in assemble stage
+                    }
+                )
             except Exception as exc:
                 LOGGER.exception("Failed sample %s", ctx["sample_id"])
                 failures.append({"sample_id": ctx["sample_id"], "error": str(exc)})
@@ -174,14 +190,23 @@ def run_stage_extract(settings: ExtractSettings) -> None:
             img = img.convert("RGB")
         img.save(sample_dir / "source.png")
 
-        contexts.append({"sample_id": sample_id, "dataset_index": idx, "sample_dir": sample_dir, "image": img.copy()})
-        requests.append({
-            "image": contexts[-1]["image"],
-            "prompt": settings.prompt,
-            "max_tokens": settings.max_tokens,
-            "temperature": settings.temperature,
-            "request_timeout": settings.inference.request_timeout,
-        })
+        contexts.append(
+            {
+                "sample_id": sample_id,
+                "dataset_index": idx,
+                "sample_dir": sample_dir,
+                "image": img.copy(),
+            }
+        )
+        requests.append(
+            {
+                "image": contexts[-1]["image"],
+                "prompt": settings.prompt,
+                "max_tokens": settings.max_tokens,
+                "temperature": settings.temperature,
+                "request_timeout": settings.inference.request_timeout,
+            }
+        )
         img.close()
 
         if len(requests) >= chunk_size:
@@ -190,12 +215,15 @@ def run_stage_extract(settings: ExtractSettings) -> None:
     flush()
 
     # Save manifest
-    write_json(settings.output_dir / "manifest.json", {
-        "generated_at": _now_iso(),
-        "stage": "extract",
-        "documents_count": doc_count,
-        "failures": failures,
-    })
+    write_json(
+        settings.output_dir / "manifest.json",
+        {
+            "generated_at": _now_iso(),
+            "stage": "extract",
+            "documents_count": doc_count,
+            "failures": failures,
+        },
+    )
 
     # Load as HF dataset
     ds = load_dataset("json", data_files=batch_files, features=_dataset_features())
@@ -206,19 +234,27 @@ def run_stage_extract(settings: ExtractSettings) -> None:
     storage.save_dataset(ds, "dataset")
 
     elapsed = time.time() - stage_start
-    LOGGER.info("✅ Extract complete | docs=%d | failures=%d | duration=%s", 
-                doc_count, len(failures), _format_duration(elapsed))
+    LOGGER.info(
+        "✅ Extract complete | docs=%d | failures=%d | duration=%s",
+        doc_count,
+        len(failures),
+        _format_duration(elapsed),
+    )
 
 
 def run_stage_describe(settings: DescribeSettings) -> None:
     """Describe figures in the dataset that lack descriptions."""
     stage_start = time.time()
     LOGGER.info("⏳ Starting DESCRIBE stage...")
-    
+
     # Get source storage and load dataset
-    source_storage = get_source_storage(source_repo_id=settings.source_repo_id or settings.hub.repo_id)
+    source_storage = get_source_storage(
+        source_repo_id=settings.source_repo_id or settings.hub.repo_id
+    )
     if not source_storage.is_configured:
-        raise ValueError("No source configured for describe stage (set SOURCE_REPO_ID, HF_REPO_ID, or S3_INPUT_URI)")
+        raise ValueError(
+            "No source configured for describe stage (set SOURCE_REPO_ID, HF_REPO_ID, or S3_INPUT_URI)"
+        )
 
     dataset = source_storage.load_dataset()
     if dataset is None:
@@ -282,18 +318,28 @@ def run_stage_describe(settings: DescribeSettings) -> None:
             fig_id = meta.get("figure_id", "")
 
             if i >= len(images) or images[i] is None:
-                failures.append({"sample_id": sample_id, "figure_id": fig_id, "reason": "missing_image"})
+                failures.append(
+                    {
+                        "sample_id": sample_id,
+                        "figure_id": fig_id,
+                        "reason": "missing_image",
+                    }
+                )
                 continue
 
             fig_img = images[i]
-            contexts.append({"sample_id": sample_id, "figure_id": fig_id, "image": fig_img})
-            requests.append({
-                "image": fig_img,
-                "prompt": settings.prompt,
-                "max_tokens": settings.max_tokens,
-                "temperature": settings.temperature,
-                "request_timeout": settings.inference.request_timeout,
-            })
+            contexts.append(
+                {"sample_id": sample_id, "figure_id": fig_id, "image": fig_img}
+            )
+            requests.append(
+                {
+                    "image": fig_img,
+                    "prompt": settings.prompt,
+                    "max_tokens": settings.max_tokens,
+                    "temperature": settings.temperature,
+                    "request_timeout": settings.inference.request_timeout,
+                }
+            )
 
             if len(requests) >= chunk_size:
                 flush()
@@ -316,8 +362,11 @@ def run_stage_describe(settings: DescribeSettings) -> None:
         LOGGER.info("No descriptions generated")
         return
 
-    LOGGER.info("Lookup has %d descriptions, first few: %s", 
-                len(lookup), list(lookup.keys())[:3])
+    LOGGER.info(
+        "Lookup has %d descriptions, first few: %s",
+        len(lookup),
+        list(lookup.keys())[:3],
+    )
 
     def apply(row):
         metas = row.get("extracted_figures_metadata") or []
@@ -336,28 +385,40 @@ def run_stage_describe(settings: DescribeSettings) -> None:
     # Verify before saving
     test_meta = updated[0]["extracted_figures_metadata"]
     if test_meta:
-        test_parsed = json.loads(test_meta[0]) if isinstance(test_meta[0], str) else test_meta[0]
-        LOGGER.info("VERIFY before save - description present: %s", 
-                    test_parsed.get("description") is not None)
+        test_parsed = (
+            json.loads(test_meta[0]) if isinstance(test_meta[0], str) else test_meta[0]
+        )
+        LOGGER.info(
+            "VERIFY before save - description present: %s",
+            test_parsed.get("description") is not None,
+        )
 
     # Get output storage and save
     storage = get_storage(repo_id=settings.hub.repo_id)
     storage.save_dataset(updated, "dataset")
 
     elapsed = time.time() - stage_start
-    LOGGER.info("✅ Describe complete | described=%d | failures=%d | duration=%s", 
-                described, len(failures), _format_duration(elapsed))
+    LOGGER.info(
+        "✅ Describe complete | described=%d | failures=%d | duration=%s",
+        described,
+        len(failures),
+        _format_duration(elapsed),
+    )
 
 
 def run_stage_assemble(settings: AssembleSettings) -> None:
     """Enrich markdown with figure descriptions."""
     stage_start = time.time()
     LOGGER.info("⏳ Starting ASSEMBLE stage...")
-    
+
     # Get source storage and load dataset
-    source_storage = get_source_storage(source_repo_id=settings.source_repo_id or settings.hub.repo_id)
+    source_storage = get_source_storage(
+        source_repo_id=settings.source_repo_id or settings.hub.repo_id
+    )
     if not source_storage.is_configured:
-        raise ValueError("No source configured for assemble stage (set SOURCE_REPO_ID, HF_REPO_ID, or S3_INPUT_URI)")
+        raise ValueError(
+            "No source configured for assemble stage (set SOURCE_REPO_ID, HF_REPO_ID, or S3_INPUT_URI)"
+        )
 
     dataset = source_storage.load_dataset()
     if dataset is None:
@@ -393,5 +454,8 @@ def run_stage_assemble(settings: AssembleSettings) -> None:
     storage.save_dataset(dataset, "dataset")
 
     elapsed = time.time() - stage_start
-    LOGGER.info("✅ Assemble complete | assembled=%d | duration=%s", 
-                assembled_count, _format_duration(elapsed))
+    LOGGER.info(
+        "✅ Assemble complete | assembled=%d | duration=%s",
+        assembled_count,
+        _format_duration(elapsed),
+    )

llm_ocr/storage.py

@@ -5,11 +5,12 @@ abstracting away whether we're using HuggingFace Hub, S3, or GCS.
 
 Usage:
     from .storage import get_storage
-    
+
     storage = get_storage()
     storage.save_dataset(dataset, "my_dataset")
     dataset = storage.load_dataset()
 """
+
 from __future__ import annotations
 
 import logging
@@ -26,32 +27,17 @@ LOGGER = logging.getLogger(__name__)
 
 class DatasetStorage(ABC):
     """Abstract base class for dataset storage backends."""
-    
+
     @abstractmethod
     def save_dataset(self, dataset: "Dataset", name: str) -> bool:
-        """Save a HuggingFace dataset to storage.
-        
-        Args:
-            dataset: HuggingFace Dataset to save
-            name: Name/identifier for the dataset
-            
-        Returns:
-            True if save succeeded
-        """
+        """Save dataset to storage. Returns True on success."""
         pass
-    
+
     @abstractmethod
     def load_dataset(self, split: str = "train") -> Optional["Dataset"]:
-        """Load a HuggingFace dataset from storage.
-        
-        Args:
-            split: Dataset split to load
-            
-        Returns:
-            Loaded Dataset or None if not available
-        """
+        """Load dataset from storage. Returns None if unavailable."""
         pass
-    
+
     @property
     @abstractmethod
     def is_configured(self) -> bool:
@@ -61,7 +47,7 @@ class DatasetStorage(ABC):
 
 class HFHubStorage(DatasetStorage):
     """HuggingFace Hub storage backend."""
-    
+
     def __init__(
         self,
         repo_id: Optional[str] = None,
@@ -72,23 +58,23 @@ class HFHubStorage(DatasetStorage):
         self.branch = branch or env("HF_BRANCH")
         self.commit_message = commit_message or env("HF_COMMIT_MESSAGE")
         self._token = env("HF_TOKEN")
-    
+
     @property
     def is_configured(self) -> bool:
         return bool(self.repo_id)
-    
+
     def save_dataset(self, dataset: "Dataset", name: str) -> bool:
         if not self.is_configured:
             LOGGER.debug("HF Hub not configured, skipping dataset save")
             return False
-        
+
         # Fail early if token is missing or empty
         if not self._token:
             raise ValueError(
                 "HF_TOKEN is required to push datasets to the Hub. "
                 "Set the HF_TOKEN environment variable with a token that has write permissions."
             )
-        
+
         try:
             dataset.push_to_hub(
                 self.repo_id,
@@ -101,15 +87,15 @@ class HFHubStorage(DatasetStorage):
         except Exception as exc:
             LOGGER.exception("HF Hub dataset push failed: %s", exc)
             raise
-    
+
     def load_dataset(self, split: str = "train") -> Optional["Dataset"]:
         if not self.is_configured:
             LOGGER.debug("HF Hub not configured, cannot load dataset")
             return None
-        
+
         try:
             from datasets import load_dataset
-            
+
             LOGGER.info("Loading dataset from HF Hub: %s", self.repo_id)
             return load_dataset(self.repo_id, split=split, token=self._token)
         except Exception as exc:
@@ -119,7 +105,7 @@ class HFHubStorage(DatasetStorage):
 
 class S3Storage(DatasetStorage):
     """Amazon S3 storage backend."""
-    
+
     def __init__(
         self,
         output_uri: Optional[str] = None,
@@ -127,19 +113,19 @@ class S3Storage(DatasetStorage):
     ):
         self.output_uri = output_uri or env("S3_OUTPUT_URI")
         self.input_uri = input_uri or env("S3_INPUT_URI")
-    
+
     @property
     def is_configured(self) -> bool:
         return bool(self.output_uri or self.input_uri)
-    
+
     def save_dataset(self, dataset: "Dataset", name: str) -> bool:
         if not self.output_uri:
             LOGGER.debug("S3 output URI not configured, skipping dataset save")
             return False
-        
+
         try:
             from .sm_io import save_dataset_to_s3
-            
+
             save_dataset_to_s3(dataset, self.output_uri, name)
             return True
         except ImportError as exc:
@@ -148,15 +134,15 @@ class S3Storage(DatasetStorage):
         except Exception as exc:
             LOGGER.exception("S3 dataset save failed: %s", exc)
             return False
-    
+
     def load_dataset(self, split: str = "train") -> Optional["Dataset"]:
         if not self.input_uri:
             LOGGER.debug("S3 input URI not configured, cannot load dataset")
             return None
-        
+
         try:
             from .sm_io import load_dataset_from_s3
-            
+
             return load_dataset_from_s3(self.input_uri, split=split)
         except ImportError as exc:
             LOGGER.warning("S3 load failed (missing dependency): %s", exc)
@@ -168,7 +154,7 @@ class S3Storage(DatasetStorage):
 
 class GCSStorage(DatasetStorage):
     """Google Cloud Storage backend."""
-    
+
     def __init__(
         self,
         output_uri: Optional[str] = None,
@@ -176,19 +162,19 @@ class GCSStorage(DatasetStorage):
     ):
         self.output_uri = output_uri or env("GCS_OUTPUT_URI")
         self.input_uri = input_uri or env("GCS_INPUT_URI")
-    
+
     @property
     def is_configured(self) -> bool:
         return bool(self.output_uri or self.input_uri)
-    
+
     def save_dataset(self, dataset: "Dataset", name: str) -> bool:
         if not self.output_uri:
             LOGGER.debug("GCS output URI not configured, skipping dataset save")
             return False
-        
+
         try:
             from .cloudrun_io import save_dataset_to_gcs
-            
+
             save_dataset_to_gcs(dataset, self.output_uri, name)
             return True
         except ImportError as exc:
@@ -197,15 +183,15 @@ class GCSStorage(DatasetStorage):
         except Exception as exc:
             LOGGER.exception("GCS dataset save failed: %s", exc)
             return False
-    
+
     def load_dataset(self, split: str = "train") -> Optional["Dataset"]:
         if not self.input_uri:
             LOGGER.debug("GCS input URI not configured, cannot load dataset")
             return None
-        
+
         try:
             from .cloudrun_io import load_dataset_from_gcs
-            
+
             return load_dataset_from_gcs(self.input_uri, split=split)
         except ImportError as exc:
             LOGGER.warning("GCS load failed (missing dependency): %s", exc)
@@ -223,25 +209,26 @@ def get_storage(
     gcs_output_uri: Optional[str] = None,
     gcs_input_uri: Optional[str] = None,
 ) -> DatasetStorage:
-    """Get the appropriate storage backend based on configuration.
-    
-    Priority: GCS > S3 > HF Hub.
-    
-    Args:
-        repo_id: Override HF repo ID
-        s3_output_uri: Override S3 output URI
-        s3_input_uri: Override S3 input URI
-        gcs_output_uri: Override GCS output URI
-        gcs_input_uri: Override GCS input URI
-        
-    Returns:
-        Configured DatasetStorage instance
-    """
+    """Get the configured storage backend. Exactly one must be configured."""
     gcs = GCSStorage(output_uri=gcs_output_uri, input_uri=gcs_input_uri)
     s3 = S3Storage(output_uri=s3_output_uri, input_uri=s3_input_uri)
     hf = HFHubStorage(repo_id=repo_id)
-    
-    # Return first configured backend
+
+    configured = [
+        name
+        for name, backend in [("GCS", gcs), ("S3", s3), ("HF Hub", hf)]
+        if backend.is_configured
+    ]
+
+    if len(configured) > 1:
+        raise ValueError(
+            f"Multiple storage backends configured: {configured}. Configure only one."
+        )
+    if len(configured) == 0:
+        raise ValueError(
+            "No storage backend configured. Set HF_REPO_ID, S3_OUTPUT_URI, or GCS_OUTPUT_URI."
+        )
+
     if gcs.is_configured:
         return gcs
     if s3.is_configured:
@@ -253,23 +240,28 @@ def get_source_storage(
     *,
     source_repo_id: Optional[str] = None,
 ) -> DatasetStorage:
-    """Get storage backend for loading source data.
-    
-    Checks GCS_INPUT_URI first, then S3_INPUT_URI, then falls back to HF Hub.
-    
-    Args:
-        source_repo_id: HF repo ID to load from (falls back to SOURCE_REPO_ID env var)
-        
-    Returns:
-        Configured DatasetStorage instance for loading
-    """
+    """Get storage for loading source data. Exactly one must be configured."""
     gcs_input = env("GCS_INPUT_URI")
+    s3_input = env("S3_INPUT_URI")
+    hf_repo = source_repo_id or env("SOURCE_REPO_ID") or env("HF_REPO_ID")
+
+    configured = [
+        name
+        for name, val in [("GCS", gcs_input), ("S3", s3_input), ("HF Hub", hf_repo)]
+        if val
+    ]
+
+    if len(configured) > 1:
+        raise ValueError(
+            f"Multiple source backends configured: {configured}. Configure only one."
+        )
+    if len(configured) == 0:
+        raise ValueError(
+            "No source storage configured. Set SOURCE_REPO_ID, S3_INPUT_URI, or GCS_INPUT_URI."
+        )
+
     if gcs_input:
         return GCSStorage(input_uri=gcs_input)
-    
-    s3_input = env("S3_INPUT_URI")
     if s3_input:
         return S3Storage(input_uri=s3_input)
-    
-    repo_id = source_repo_id or env("SOURCE_REPO_ID") or env("HF_REPO_ID")
-    return HFHubStorage(repo_id=repo_id)
+    return HFHubStorage(repo_id=hf_repo)