Added UV script to move from single page OCR to consolidated OCR

consolidate_ocr_dataset.py

@@ -0,0 +1,320 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#   "datasets>=3.0.0",
+#   "huggingface_hub>=0.24.0",
+# ]
+# ///
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+from collections import OrderedDict
+from typing import Any
+
+from datasets import Dataset, DatasetDict, load_dataset
+
+
+PAGE_RE = re.compile(r"_(\d{3,})-")
+
+
+DEFAULT_KEEP_COLUMNS = [
+    "title",
+    "barcode",
+    "call_number",
+    "location",
+    "date_scanned",
+    "scanned_by",
+    "ld4p_id",
+    "original_zip",
+]
+
+
+def normalize_value(value: Any) -> Any:
+    """Make values safe and stable for Dataset.from_list."""
+    if value is None:
+        return None
+
+    if isinstance(value, (str, int, float, bool)):
+        return value
+
+    try:
+        return json.dumps(value, ensure_ascii=False, sort_keys=True)
+    except TypeError:
+        return str(value)
+
+
+def parse_page_number(source_path: str | None) -> int | None:
+    if not source_path:
+        return None
+
+    match = PAGE_RE.search(source_path)
+    if match:
+        return int(match.group(1))
+
+    return None
+
+
+def make_document_id(row: dict[str, Any], group_by: list[str]) -> str:
+    values = [str(row.get(col, "")).strip() for col in group_by]
+    return "::".join(values)
+
+
+def reduce_split(
+    ds: Dataset,
+    *,
+    group_by: list[str],
+    keep_columns: list[str],
+    markdown_column: str,
+    source_path_column: str,
+    inference_info_column: str,
+    add_page_markers: bool,
+) -> Dataset:
+    missing_group_cols = [col for col in group_by if col not in ds.column_names]
+    if missing_group_cols:
+        raise ValueError(f"Missing grouping columns: {missing_group_cols}")
+
+    if markdown_column not in ds.column_names:
+        raise ValueError(f"Missing markdown column: {markdown_column}")
+
+    if source_path_column not in ds.column_names:
+        raise ValueError(f"Missing source path column: {source_path_column}")
+
+    # Crucial: remove image/reference image columns before row iteration.
+    # This avoids decoding or carrying image payloads into the reduced dataset.
+    early_drop_columns = [col for col in ["image"] if col in ds.column_names]
+    if early_drop_columns:
+        ds = ds.remove_columns(early_drop_columns)
+
+    keep_columns = [col for col in keep_columns if col in ds.column_names]
+
+    documents: OrderedDict[tuple[Any, ...], dict[str, Any]] = OrderedDict()
+
+    for row_index, row in enumerate(ds):
+        key = tuple(normalize_value(row.get(col)) for col in group_by)
+
+        if key not in documents:
+            doc = {
+                col: normalize_value(row.get(col))
+                for col in keep_columns
+            }
+
+            doc["document_id"] = make_document_id(row, group_by)
+            doc["_pages"] = []
+            documents[key] = doc
+
+        source_path = row.get(source_path_column)
+        page_number = parse_page_number(source_path)
+
+        documents[key]["_pages"].append(
+            {
+                "row_index": row_index,
+                "page_number": page_number,
+                "source_path": normalize_value(source_path),
+                "markdown": row.get(markdown_column) or "",
+                "inference_info": normalize_value(row.get(inference_info_column))
+                if inference_info_column in ds.column_names
+                else None,
+            }
+        )
+
+    output_rows: list[dict[str, Any]] = []
+
+    for doc in documents.values():
+        pages = sorted(
+            doc["_pages"],
+            key=lambda p: (
+                p["page_number"] is None,
+                p["page_number"] if p["page_number"] is not None else 10**12,
+                p["row_index"],
+            ),
+        )
+
+        markdown_parts = []
+        for idx, page in enumerate(pages, start=1):
+            text = page["markdown"].strip()
+
+            if add_page_markers:
+                marker = f"<!-- page {idx}; source_path: {page['source_path']} -->"
+                markdown_parts.append(f"{marker}\n\n{text}".strip())
+            else:
+                markdown_parts.append(text)
+
+        source_paths = [p["source_path"] for p in pages]
+        page_numbers = [p["page_number"] for p in pages]
+
+        inference_infos = [
+            p["inference_info"]
+            for p in pages
+            if p.get("inference_info") not in (None, "")
+        ]
+
+        doc.pop("_pages", None)
+
+        doc[markdown_column] = "\n\n".join(part for part in markdown_parts if part)
+        doc["page_count"] = len(pages)
+        doc["source_paths"] = source_paths
+        doc["page_numbers"] = page_numbers
+
+        # Usually identical across pages; keep first value as document-level metadata.
+        doc[inference_info_column] = inference_infos[0] if inference_infos else None
+
+        output_rows.append(doc)
+
+    return Dataset.from_list(output_rows)
+
+
+def parse_csv_arg(value: str) -> list[str]:
+    return [part.strip() for part in value.split(",") if part.strip()]
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Consolidate page-level OCR rows into document-level OCR rows."
+    )
+
+    parser.add_argument(
+        "--input-dataset",
+        required=True,
+        help="Input Hugging Face dataset repo ID, e.g. username/page-level-ocr",
+    )
+
+    parser.add_argument(
+        "--output-dataset",
+        required=True,
+        help="Output Hugging Face dataset repo ID, e.g. username/document-level-ocr",
+    )
+
+    parser.add_argument(
+        "--config",
+        default=None,
+        help="Optional dataset config/subset name.",
+    )
+
+    parser.add_argument(
+        "--split",
+        default=None,
+        help="Optional split to process. If omitted, all splits are processed.",
+    )
+
+    parser.add_argument(
+        "--group-by",
+        default="barcode",
+        help="Comma-separated grouping columns. Default: barcode",
+    )
+
+    parser.add_argument(
+        "--keep-columns",
+        default=",".join(DEFAULT_KEEP_COLUMNS),
+        help="Comma-separated metadata columns to preserve.",
+    )
+
+    parser.add_argument(
+        "--markdown-column",
+        default="markdown",
+        help="OCR text column to concatenate. Default: markdown",
+    )
+
+    parser.add_argument(
+        "--source-path-column",
+        default="source_path",
+        help="Column used to infer page order. Default: source_path",
+    )
+
+    parser.add_argument(
+        "--inference-info-column",
+        default="inference_info",
+        help="Column containing OCR inference metadata. Default: inference_info",
+    )
+
+    parser.add_argument(
+        "--no-page-markers",
+        action="store_true",
+        help="Do not insert HTML page markers into the consolidated markdown.",
+    )
+
+    parser.add_argument(
+        "--private",
+        action="store_true",
+        help="Create the output dataset as private if it does not already exist.",
+    )
+
+    parser.add_argument(
+        "--token",
+        default=os.environ.get("HF_TOKEN"),
+        help="Hugging Face token. Defaults to HF_TOKEN environment variable.",
+    )
+
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Print a summary instead of pushing to the Hub.",
+    )
+
+    args = parser.parse_args()
+
+    group_by = parse_csv_arg(args.group_by)
+    keep_columns = parse_csv_arg(args.keep_columns)
+
+    load_kwargs: dict[str, Any] = {
+        "path": args.input_dataset,
+    }
+
+    if args.config:
+        load_kwargs["name"] = args.config
+
+    if args.split:
+        load_kwargs["split"] = args.split
+
+    if args.token:
+        load_kwargs["token"] = args.token
+
+    loaded = load_dataset(**load_kwargs)
+
+    reduce_kwargs = {
+        "group_by": group_by,
+        "keep_columns": keep_columns,
+        "markdown_column": args.markdown_column,
+        "source_path_column": args.source_path_column,
+        "inference_info_column": args.inference_info_column,
+        "add_page_markers": not args.no_page_markers,
+    }
+
+    if isinstance(loaded, DatasetDict):
+        reduced = DatasetDict(
+            {
+                split_name: reduce_split(split_ds, **reduce_kwargs)
+                for split_name, split_ds in loaded.items()
+            }
+        )
+    else:
+        reduced = reduce_split(loaded, **reduce_kwargs)
+
+    if args.dry_run:
+        if isinstance(reduced, DatasetDict):
+            for split_name, split_ds in reduced.items():
+                print(f"{split_name}: {split_ds.num_rows} consolidated documents")
+                print(split_ds[0] if split_ds.num_rows else "No rows")
+        else:
+            print(f"{reduced.num_rows} consolidated documents")
+            print(reduced[0] if reduced.num_rows else "No rows")
+        return
+
+    push_kwargs: dict[str, Any] = {
+        "repo_id": args.output_dataset,
+        "private": args.private,
+    }
+
+    if args.token:
+        push_kwargs["token"] = args.token
+
+    reduced.push_to_hub(**push_kwargs)
+
+    print(f"Pushed consolidated dataset to: {args.output_dataset}")
+
+
+if __name__ == "__main__":
+    main()