Upload folder using huggingface_hub

hf_job_runner.py

@@ -3,7 +3,7 @@
 # dependencies = [
 #     "huggingface-hub[hf_transfer,hf_xet]",
 #     "torch",
-#     "datasets>=2.0.0",
+#     "datasets>=4.0.0",
 #     "pyarrow>=12.0.0",
 #     "numpy",
 #     "pillow",

llm_ocr/config.py

@@ -26,11 +26,9 @@ def env(key: str, default: T = None, cast: Type[T] = str) -> T:
 
 @dataclass
 class FigureMetadata:
-    """Metadata for an extracted figure."""
+    """Metadata for an extracted figure (image stored in dataset, not as file)."""
     figure_id: str
     label: str
-    image_path: str
-    document_relative_path: str
     bounding_box_pixels: Dict[str, int]
     description: Optional[str] = None
 

llm_ocr/document.py

@@ -8,7 +8,7 @@ import logging
 import re
 from io import BytesIO
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Tuple
 
 import numpy as np
 from PIL import Image, ImageDraw, ImageFont
@@ -22,8 +22,9 @@ GROUNDING_PATTERN = re.compile(
     re.DOTALL,
 )
 
+# Matches both old path format and new figure: URI format
 FIGURE_MARKDOWN_PATTERN = re.compile(
-    r"!\[Figure (?P<figure_id>[^\]]+)\]\((?P<path>[^)]+)\)"
+    r"!\[(?:Figure )?(?P<figure_id>[^\]]+)\]\((?P<path>[^)]+)\)"
 )
 
 
@@ -81,40 +82,30 @@ def apply_replacements(text: str, replacements: List[Tuple[int, int, str]]) -> s
     return postprocess_markdown("".join(segments))
 
 
-def save_figure(
+def crop_figure(
     image: Image.Image,
-    sample_dir: Path,
     sample_id: str,
     figure_index: int,
     pixel_box: List[int],
     label: str,
-    path_prefix: str = "",
-) -> Optional[FigureMetadata]:
-    """Crop and save a figure from the source image."""
+) -> Tuple[FigureMetadata, Image.Image]:
+    """Crop a figure from the source image.
+    
+    Returns:
+        Tuple of (metadata, cropped_image) - image is for embedding in dataset
+    """
     x1, y1, x2, y2 = pixel_box
     crop = image.crop((x1, y1, x2, y2)).copy()
 
-    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"
-    full_path = figures_dir / figure_filename
-    crop.save(full_path)
-
-    # Path relative to dataset root (includes path_prefix like "outputs/extract")
-    if path_prefix:
-        document_relative_path = f"{path_prefix}/{sample_id}/figures/{figure_filename}"
-    else:
-        document_relative_path = f"{sample_id}/figures/{figure_filename}"
 
-    return FigureMetadata(
+    metadata = FigureMetadata(
         figure_id=figure_id,
         label=label,
-        image_path=str(full_path),
-        document_relative_path=document_relative_path,
         bounding_box_pixels={"x1": x1, "y1": y1, "x2": x2, "y2": y2},
     )
+    
+    return metadata, crop
 
 
 def write_text(path: Path, content: str) -> None:
@@ -133,24 +124,21 @@ def write_json(path: Path, payload: Any) -> None:
 def build_document_markdown(
     image: Image.Image,
     response_text: str,
-    sample_dir: Path,
     sample_id: str,
-    path_prefix: str = "",
-) -> Tuple[str, List[FigureMetadata], Image.Image]:
+) -> Tuple[str, List[FigureMetadata], List[Image.Image], Image.Image]:
     """
     Process model response to extract markdown and figures.
     
-    Args:
-        path_prefix: Prefix for paths in markdown (e.g., "outputs/extract")
-    
     Returns:
-        - Cleaned markdown with figure references
-        - List of extracted figure metadata
+        - 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
     """
     blocks = extract_grounding_blocks(response_text)
     replacements: List[Tuple[int, int, str]] = []
     figures: List[FigureMetadata] = []
+    figure_images: List[Image.Image] = []
     figure_index = 1
 
     img_draw = image.copy()
@@ -179,24 +167,21 @@ def build_document_markdown(
 
         # Extract figures (images)
         if label == "image":
-            figure_metadata = save_figure(
+            metadata, crop = crop_figure(
                 image=image,
-                sample_dir=sample_dir,
                 sample_id=sample_id,
                 figure_index=figure_index,
                 pixel_box=pixel_box,
                 label=block["label"],
-                path_prefix=path_prefix,
             )
-            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, ""))
+            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})",
+            ))
+            figure_index += 1
         else:
             replacements.append((start, end, ""))
 
@@ -214,19 +199,31 @@ def build_document_markdown(
 
     img_draw.paste(overlay, (0, 0), overlay)
     markdown = apply_replacements(response_text, replacements)
-    return markdown, figures, img_draw
+    return markdown, figures, figure_images, img_draw
 
 
 def enrich_markdown_with_captions(
     markdown: str,
     description_map: Dict[str, Dict[str, Any]],
 ) -> str:
-    """Add figure captions to markdown based on descriptions."""
+    """Add figure captions to markdown based on descriptions.
+    
+    Handles both new format ![figure_id](figure:figure_id) and 
+    legacy format ![Figure figure_id](path).
+    """
     used: set[str] = set()
 
     def replace(match: re.Match[str]) -> str:
-        figure_id = match.group("figure_id").strip()
+        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)
@@ -235,20 +232,102 @@ def enrich_markdown_with_captions(
         if not description:
             return match.group(0)
 
-        alt_text = f"Figure {figure_id}: {description}"
-        rendered = f"![{alt_text}]({path})"
+        # Create enriched alt text with description
+        new_alt_text = f"{figure_id}: {description}"
+        rendered = f"![{new_alt_text}]({path})"
         if figure_id not in used:
-            rendered += f"\n\n*Figure {figure_id}: {description}*\n"
+            rendered += f"\n\n*{figure_id}: {description}*\n"
             used.add(figure_id)
         return rendered
 
     return FIGURE_MARKDOWN_PATTERN.sub(replace, markdown)
 
 
+def render_markdown_with_images(
+    markdown: str,
+    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
+    """
+    # 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 ""
+    
+    # Parse metadata
+    raw_metadata = sample.get("extracted_figures_metadata") or []
+    metadata = []
+    for m in raw_metadata:
+        if isinstance(m, 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,
+        figure_metadata=metadata,
+    )
+
+
 __all__ = [
     "encode_image",
     "build_document_markdown",
     "enrich_markdown_with_captions",
+    "render_markdown_with_images",
+    "render_sample_markdown",
     "write_text",
     "write_json",
 ]

llm_ocr/gcr_io.py

@@ -122,8 +122,24 @@ def save_dataset_to_gcs(
     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 from GCS (Arrow format).
+    """Load HF dataset directly from GCS (saved with save_to_disk).
     
     Args:
         gcs_uri: GCS URI to dataset directory (gs://bucket/path/to/dataset/)
@@ -131,41 +147,18 @@ def load_dataset_from_gcs(gcs_uri: str, split: str = "train") -> "Dataset":
         
     Returns:
         Loaded Dataset
+        
+    Requires:
+        pip install datasets gcsfs
     """
     from datasets import load_from_disk
     
-    bucket_name, prefix = parse_gcs_uri(gcs_uri)
-    prefix = prefix.rstrip("/")
+    LOGGER.info("Loading dataset from %s", gcs_uri)
     
-    client = get_gcs_client()
-    bucket = client.bucket(bucket_name)
+    # load_from_disk supports GCS URIs directly with gcsfs
+    ds = load_from_disk(gcs_uri)
     
-    # Create temp directory for download
-    local_dir = Path(f"/tmp/gcs_arrow_{prefix.replace('/', '_')}")
-    if local_dir.exists():
-        shutil.rmtree(local_dir)
-    local_dir.mkdir(parents=True)
-    
-    # Download all files from GCS prefix
-    blobs = list(bucket.list_blobs(prefix=prefix))
-    file_count = 0
-    
-    for blob in blobs:
-        # Get relative path from prefix
-        rel_path = blob.name[len(prefix):].lstrip("/")
-        if not rel_path:
-            continue
-        local_path = local_dir / rel_path
-        local_path.parent.mkdir(parents=True, exist_ok=True)
-        LOGGER.info("Downloading gs://%s/%s", bucket_name, blob.name)
-        blob.download_to_filename(str(local_path))
-        file_count += 1
-    
-    if file_count == 0:
-        raise FileNotFoundError(f"No files found at {gcs_uri}")
-    
-    LOGGER.info("Loading dataset from %d files", file_count)
-    return load_from_disk(str(local_dir))
+    return ds
 
 
 __all__ = [

llm_ocr/sm_io.py

@@ -126,8 +126,24 @@ def save_dataset_to_s3(
     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 from S3 (Arrow format).
+    """Load HF dataset directly from S3 (saved with save_to_disk).
     
     Args:
         s3_uri: S3 URI to dataset directory (s3://bucket/path/to/dataset/)
@@ -135,41 +151,18 @@ def load_dataset_from_s3(s3_uri: str, split: str = "train") -> "Dataset":
         
     Returns:
         Loaded Dataset
+        
+    Requires:
+        pip install datasets[s3] s3fs
     """
     from datasets import load_from_disk
     
-    bucket, prefix = parse_s3_uri(s3_uri)
-    prefix = prefix.rstrip("/")
-    s3 = get_s3_client()
+    LOGGER.info("Loading dataset from %s", s3_uri)
     
-    # Create temp directory for download
-    local_dir = Path(f"/tmp/s3_arrow_{prefix.replace('/', '_')}")
-    if local_dir.exists():
-        shutil.rmtree(local_dir)
-    local_dir.mkdir(parents=True)
-    
-    # Download all files from S3 prefix
-    paginator = s3.get_paginator("list_objects_v2")
-    file_count = 0
-    
-    for page in paginator.paginate(Bucket=bucket, Prefix=prefix):
-        for obj in page.get("Contents", []):
-            key = obj["Key"]
-            # Get relative path from prefix
-            rel_path = key[len(prefix):].lstrip("/")
-            if not rel_path:
-                continue
-            local_path = local_dir / rel_path
-            local_path.parent.mkdir(parents=True, exist_ok=True)
-            LOGGER.info("Downloading s3://%s/%s", bucket, key)
-            s3.download_file(bucket, key, str(local_path))
-            file_count += 1
-    
-    if file_count == 0:
-        raise FileNotFoundError(f"No files found at {s3_uri}")
-    
-    LOGGER.info("Loading dataset from %d files", file_count)
-    return load_from_disk(str(local_dir))
+    # load_from_disk supports S3 URIs directly with s3fs
+    ds = load_from_disk(s3_uri, storage_options={"anon": False})
+    
+    return ds
 
 
 __all__ = [

llm_ocr/stages.py

@@ -14,7 +14,7 @@ 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, write_text
+from .document import build_document_markdown, enrich_markdown_with_captions, write_json
 from .storage import get_storage, get_source_storage
 
 LOGGER = logging.getLogger(__name__)
@@ -104,15 +104,23 @@ def run_stage_extract(settings: ExtractSettings) -> None:
                 sample_dir = ctx["sample_dir"]
                 sample_id = ctx["sample_id"]
 
-                markdown, figures, img_draw = build_document_markdown(
-                    image=img, response_text=text, sample_dir=sample_dir, 
-                    sample_id=sample_id, path_prefix=""
+                markdown, figures, figure_images, img_draw = build_document_markdown(
+                    image=img, response_text=text, sample_id=sample_id,
                 )
                 
-                # Save images locally for dataset loading
+                # 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)
+                figure_paths = []
+                for fig_meta, fig_img in zip(figures, figure_images):
+                    fig_path = figures_dir / f"{fig_meta.figure_id}.png"
+                    fig_img.save(fig_path)
+                    figure_paths.append(str(fig_path))
 
                 docs.append({
                     "sample_id": sample_id,
@@ -120,7 +128,7 @@ def run_stage_extract(settings: ExtractSettings) -> None:
                     "source_image": str(source_path),
                     "document_with_boxes_image": str(boxes_path),
                     "document_markdown": markdown,
-                    "extracted_figures": [str(f.image_path) for f in figures],
+                    "extracted_figures": figure_paths,
                     "extracted_figures_metadata": [json.dumps(asdict(f)) for f in figures],
                     "document_final_markdown": "",  # Filled in assemble stage
                 })
@@ -290,6 +298,8 @@ def run_stage_describe(settings: DescribeSettings) -> None:
         LOGGER.info("No descriptions generated")
         return
 
+    LOGGER.info("Applying %d descriptions to dataset", len(lookup))
+
     def apply(row):
         metas = row.get("extracted_figures_metadata") or []
         new_metas = []
@@ -298,12 +308,19 @@ def run_stage_describe(settings: DescribeSettings) -> None:
             if meta.get("figure_id") in lookup:
                 meta["description"] = lookup[meta["figure_id"]]
             new_metas.append(json.dumps(meta))
-        row["extracted_figures_metadata"] = new_metas
-        return row
+        return {"extracted_figures_metadata": new_metas}
 
-    updated = dataset.map(apply, features=dataset.features)
+    # Disable caching for this map operation to ensure fresh results
+    updated = dataset.map(apply, load_from_cache_file=False)
     shutil.rmtree(desc_dir)
 
+    # Verify descriptions were applied
+    sample_meta = updated[0].get("extracted_figures_metadata", [])
+    if sample_meta:
+        first_meta = json.loads(sample_meta[0]) if isinstance(sample_meta[0], str) else sample_meta[0]
+        LOGGER.info("Sample metadata after update: figure_id=%s, has_description=%s", 
+                    first_meta.get("figure_id"), first_meta.get("description") is not None)
+
     # Get output storage and save
     storage = get_storage(repo_id=settings.hub.repo_id)
     storage.save_dataset(updated, "dataset")