Upload folder using huggingface_hub

llm_ocr/__init__.py

@@ -1,7 +1,39 @@
-"""DeepSeek OCR pipeline package."""
+"""DeepSeek OCR pipeline package.
 
-from .cli import main
+This package provides tools for running batch OCR inference with DeepSeek-OCR
+and similar vision-language models across different cloud platforms.
 
-__all__ = ["main"]
+Example usage:
+    from llm_ocr import DeepSeekClient, ExtractSettings, run_stage_extract
 
+    client = DeepSeekClient(base_url="http://localhost:8000/v1")
+    settings = ExtractSettings.from_env(client)
+    run_stage_extract(settings)
+"""
 
+# Stage runners - main entry points for pipeline stages
+from llm_ocr.stages import (
+    run_stage_assemble,
+    run_stage_describe,
+    run_stage_extract,
+)
+
+# Configuration classes
+from llm_ocr.config import (
+    AssembleSettings,
+    DescribeSettings,
+    ExtractSettings,
+    InferenceSettings,
+)
+
+# Inference client
+from llm_ocr.server import DeepSeekClient
+
+# Storage backends
+from llm_ocr.storage import (
+    DatasetStorage,
+    GCSStorage,
+    HFHubStorage,
+    S3Storage,
+    get_storage,
+)

llm_ocr/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for `python -m llm_ocr`."""
+
+from llm_ocr.cli import main
+
+if __name__ == "__main__":
+    main()

llm_ocr/cli.py

@@ -87,6 +87,3 @@ def main() -> None:
     finally:
         if server_process is not None:
             shutdown_server(server_process)
-
-
-__all__ = ["main"]

llm_ocr/cloudrun_io.py

@@ -0,0 +1,181 @@
+"""Google Cloud Storage utilities for Cloud Run jobs."""
+from __future__ import annotations
+
+import logging
+import shutil
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from datasets import Dataset
+
+LOGGER = logging.getLogger(__name__)
+
+
+def get_gcs_client():
+    """Get GCS client."""
+    from google.cloud import storage
+    return storage.Client()
+
+
+def parse_gcs_uri(uri: str) -> tuple[str, str]:
+    """Parse gs://bucket/key into (bucket, key)."""
+    if not uri.startswith("gs://"):
+        raise ValueError(f"Invalid GCS URI: {uri}")
+    parts = uri[5:].split("/", 1)
+    bucket = parts[0]
+    key = parts[1] if len(parts) > 1 else ""
+    return bucket, key
+
+
+def upload_files_to_gcs(
+    *,
+    output_dir: Path,
+    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
+    """
+    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("/")
+
+    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)
+    
+    for local_path in files:
+        rel = local_path.relative_to(base).as_posix()
+        gcs_key = f"{full_prefix}/{rel}" if full_prefix else rel
+        try:
+            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)
+            raise
+
+
+def save_dataset_to_gcs(
+    dataset,
+    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
+    """
+    from datasets import DatasetDict
+    
+    # Handle DatasetDict by extracting the first split
+    if isinstance(dataset, DatasetDict):
+        if "train" in dataset:
+            dataset = dataset["train"]
+        else:
+            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}")
+    
+    # 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
+    """
+    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]
+        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

@@ -150,14 +150,3 @@ class AssembleSettings:
             source_repo_id=env("SOURCE_REPO_ID") or env("HF_REPO_ID"),
             hub=HubSettings.from_env("HF"),
         )
-
-
-__all__ = [
-    "env",
-    "FigureMetadata",
-    "InferenceSettings",
-    "HubSettings",
-    "ExtractSettings",
-    "DescribeSettings",
-    "AssembleSettings",
-]

llm_ocr/document.py

@@ -414,16 +414,3 @@ def display_samples(dataset, num_samples: int = 2) -> None:
                     except Exception:
                         pass
         print()
-
-
-__all__ = [
-    "encode_image",
-    "build_document_markdown",
-    "enrich_markdown_with_captions",
-    "render_markdown_with_images",
-    "render_sample_markdown",
-    "display_markdown",
-    "display_samples",
-    "write_text",
-    "write_json",
-]

llm_ocr/server.py

@@ -85,18 +85,34 @@ def shutdown_server(server_process: subprocess.Popen) -> None:
         thread.join(timeout=1)
 
 
+def _format_duration(seconds: float) -> str:
+    """Format duration as mm:ss."""
+    minutes = int(seconds // 60)
+    secs = int(seconds % 60)
+    return f"{minutes:02d}:{secs:02d}"
+
+
 def wait_for_server(url: str, timeout_s: int = None, interval_s: int = 5) -> bool:
+    """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
-    """Wait for server health endpoint to respond."""
+    
+    start_time = time.time()
+    LOGGER.info("⏳ Waiting for vLLM server to start...")
+    
     deadline = time.time() + timeout_s
     while time.time() < deadline:
         try:
             if requests.get(url, timeout=5).ok:
+                elapsed = time.time() - start_time
+                LOGGER.info("✅ vLLM server ready in %s", _format_duration(elapsed))
                 return True
         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
 
 
@@ -217,13 +233,3 @@ class DeepSeekClient:
         finally:
             asyncio.set_event_loop(None)
             loop.close()
-
-
-__all__ = [
-    "launch_vllm",
-    "shutdown_server", 
-    "wait_for_server",
-    "should_launch_server",
-    "base_url_from_env",
-    "DeepSeekClient",
-]

llm_ocr/sm_io.py

@@ -187,11 +187,3 @@ def load_dataset_from_s3(s3_uri: str, split: str = "train") -> "Dataset":
     ds = load_from_disk(local_dir)
     
     return ds
-
-
-__all__ = [
-    "save_dataset_to_s3",
-    "load_dataset_from_s3",
-    "parse_s3_uri",
-    "get_s3_client",
-]

llm_ocr/stages.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 import json
 import logging
 import shutil
+import time
 from dataclasses import asdict
 from datetime import datetime
 from pathlib import Path
@@ -11,7 +12,6 @@ from typing import Any, Dict, List
 
 from datasets import Features, Sequence, Value, load_dataset, Image as HfImage
 from PIL import Image
-from torch.utils.data import DataLoader
 
 from .config import AssembleSettings, DescribeSettings, ExtractSettings, env
 from .document import build_document_markdown, enrich_markdown_with_captions, write_json
@@ -20,6 +20,13 @@ from .storage import get_storage, get_source_storage
 LOGGER = logging.getLogger(__name__)
 
 
+def _format_duration(seconds: float) -> str:
+    """Format duration as mm:ss."""
+    minutes = int(seconds // 60)
+    secs = int(seconds % 60)
+    return f"{minutes:02d}:{secs:02d}"
+
+
 def _now_iso() -> str:
     return datetime.utcnow().isoformat() + "Z"
 
@@ -40,6 +47,12 @@ def _dataset_features() -> Features:
 
 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,
@@ -192,11 +205,16 @@ def run_stage_extract(settings: ExtractSettings) -> None:
     storage = get_storage(repo_id=settings.hub.repo_id)
     storage.save_dataset(ds, "dataset")
 
-    LOGGER.info("Extract complete | docs=%d | failures=%d", doc_count, len(failures))
+    elapsed = time.time() - stage_start
+    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)
     if not source_storage.is_configured:
@@ -326,11 +344,16 @@ def run_stage_describe(settings: DescribeSettings) -> None:
     storage = get_storage(repo_id=settings.hub.repo_id)
     storage.save_dataset(updated, "dataset")
 
-    LOGGER.info("Describe complete | described=%d | failures=%d", described, len(failures))
+    elapsed = time.time() - stage_start
+    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)
     if not source_storage.is_configured:
@@ -369,7 +392,6 @@ def run_stage_assemble(settings: AssembleSettings) -> None:
     storage = get_storage(repo_id=settings.hub.repo_id)
     storage.save_dataset(dataset, "dataset")
 
-    LOGGER.info("Assemble complete | assembled=%d", assembled_count)
-
-
-__all__ = ["run_stage_extract", "run_stage_describe", "run_stage_assemble"]
+    elapsed = time.time() - stage_start
+    LOGGER.info("✅ Assemble complete | assembled=%d | duration=%s", 
+                assembled_count, _format_duration(elapsed))

llm_ocr/storage.py

@@ -187,7 +187,7 @@ class GCSStorage(DatasetStorage):
             return False
         
         try:
-            from .gcr_io import save_dataset_to_gcs
+            from .cloudrun_io import save_dataset_to_gcs
             
             save_dataset_to_gcs(dataset, self.output_uri, name)
             return True
@@ -204,7 +204,7 @@ class GCSStorage(DatasetStorage):
             return None
         
         try:
-            from .gcr_io import load_dataset_from_gcs
+            from .cloudrun_io import load_dataset_from_gcs
             
             return load_dataset_from_gcs(self.input_uri, split=split)
         except ImportError as exc:
@@ -273,13 +273,3 @@ def get_source_storage(
     
     repo_id = source_repo_id or env("SOURCE_REPO_ID") or env("HF_REPO_ID")
     return HFHubStorage(repo_id=repo_id)
-
-
-__all__ = [
-    "DatasetStorage",
-    "HFHubStorage",
-    "S3Storage",
-    "GCSStorage",
-    "get_storage",
-    "get_source_storage",
-]