Sync DeepSeek OCR HF job code

ds_batch_ocr/stages.py

@@ -4,7 +4,7 @@ import json
 import logging
 import os
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Iterable, List, Optional
 
 import shutil
 from datasets import Dataset, Features, Sequence, Value, load_dataset, Image as HfImage
@@ -40,29 +40,77 @@ def write_jsonl(path: Path, rows: List[Dict[str, Any]]) -> None:
             handle.write("\n")
 
 
-def _coerce_to_str(value: Any) -> str:
+def append_jsonl(path: Path, rows: List[Dict[str, Any]]) -> None:
+    if not rows:
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a", encoding="utf-8") as handle:
+        for row in rows:
+            handle.write(json.dumps(row, ensure_ascii=False))
+            handle.write("\n")
+
+
+def read_jsonl(path: Path) -> List[Dict[str, Any]]:
+    if not path.exists():
+        return []
+    data: List[Dict[str, Any]] = []
+    with path.open("r", encoding="utf-8") as handle:
+        for line in handle:
+            line = line.strip()
+            if not line:
+                continue
+            data.append(json.loads(line))
+    return data
+
+
+def iter_jsonl(path: Path) -> Iterable[Dict[str, Any]]:
+    if not path.exists():
+        return []
+
+    def _generator() -> Iterable[Dict[str, Any]]:
+        with path.open("r", encoding="utf-8") as handle:
+            for line in handle:
+                line = line.strip()
+                if not line:
+                    continue
+                yield json.loads(line)
+
+    return _generator()
+
+
+def write_jsonl_iter(path: Path, rows: Iterable[Dict[str, Any]]) -> int:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    count = 0
+    with path.open("w", encoding="utf-8") as handle:
+        for row in rows:
+            handle.write(json.dumps(row, ensure_ascii=False))
+            handle.write("\n")
+            count += 1
+    return count
+
+
+def _resolve_image_path(base_dir: Path, value: Any) -> str:
     if value is None:
         return ""
-    if isinstance(value, bytes):
-        try:
-            return value.decode("utf-8")
-        except Exception:
-            return value.decode("utf-8", errors="ignore")
-    if isinstance(value, Path):
-        return value.as_posix()
-    if isinstance(value, str):
-        return value
+
     if isinstance(value, (list, tuple, set)):
+        candidate = ""
         for item in value:
-            coerced = _coerce_to_str(item)
-            if coerced:
-                return coerced
-        return ""
-    return str(value)
+            if item not in (None, ""):
+                candidate = item
+                break
+        value = candidate or ""
 
+    if isinstance(value, bytes):
+        try:
+            path_str = value.decode("utf-8")
+        except Exception:
+            path_str = value.decode("utf-8", errors="ignore")
+    elif isinstance(value, Path):
+        path_str = value.as_posix()
+    else:
+        path_str = str(value)
 
-def _resolve_image_path(base_dir: Path, value: Any) -> str:
-    path_str = _coerce_to_str(value)
     if not path_str:
         return ""
 
@@ -82,120 +130,6 @@ def _resolve_image_path(base_dir: Path, value: Any) -> str:
     return path.as_posix()
 
 
-def _normalize_figures(figures: Any) -> List[Dict[str, str]]:
-    if not figures:
-        return []
-
-    def _looks_columnar(obj: Any) -> bool:
-        if not isinstance(obj, dict) or not obj:
-            return False
-        has_sequence = False
-        for value in obj.values():
-            if value is None:
-                continue
-            if isinstance(value, (list, tuple)):
-                has_sequence = True
-                continue
-            return False
-        return has_sequence
-
-    def _expand_entries(source: Any) -> List[Any]:
-        if _looks_columnar(source):
-            lengths = [
-                len(column)
-                for column in source.values()
-                if isinstance(column, (list, tuple))
-            ]
-            max_len = max(lengths) if lengths else 0
-            expanded: List[Dict[str, Any]] = []
-            for idx in range(max_len):
-                entry: Dict[str, Any] = {}
-                for key, value in source.items():
-                    if isinstance(value, (list, tuple)):
-                        entry[key] = value[idx] if idx < len(value) else None
-                    else:
-                        entry[key] = value
-                expanded.append(entry)
-            return expanded
-        if isinstance(source, dict):
-            return [source]
-        if isinstance(source, (list, tuple, set)):
-            return list(source)
-        return [source]
-
-    def _unwrap(entry: Any) -> Any:
-        current = entry
-        # peel off single-item wrappers (e.g. [[{...}]]) common in some datasets
-        while isinstance(current, (list, tuple)) and len(current) == 1:
-            nested = current[0]
-            if isinstance(nested, (dict, list, tuple)) or hasattr(nested, "figure_id"):
-                current = nested
-            else:
-                break
-        return current
-
-    def _figure_from_entry(entry: Any) -> Dict[str, Any]:
-        normalized_entry = _unwrap(entry)
-
-        if isinstance(normalized_entry, dict):
-            return normalized_entry
-
-        if hasattr(normalized_entry, "figure_id"):
-            return {
-                "figure_id": getattr(normalized_entry, "figure_id", ""),
-                "image_path": getattr(normalized_entry, "image_path", "")
-                or getattr(normalized_entry, "document_relative_path", "")
-                or "",
-                "description": getattr(normalized_entry, "description", "") or "",
-            }
-
-        if isinstance(normalized_entry, (list, tuple)):
-            return {
-                "figure_id": normalized_entry[0] if len(normalized_entry) > 0 else "",
-                "image_path": normalized_entry[1] if len(normalized_entry) > 1 else "",
-                "description": normalized_entry[2] if len(normalized_entry) > 2 else "",
-            }
-
-        return {"figure_id": normalized_entry}
-
-    normalized: List[Dict[str, str]] = []
-    for raw_entry in _expand_entries(figures):
-        try:
-            figure_dict = _figure_from_entry(raw_entry)
-        except Exception:  # pragma: no cover - defensive guard
-            LOGGER.warning("Unable to normalize figure entry; skipping: %s", raw_entry, exc_info=True)
-            continue
-
-        figure_id = _coerce_to_str(
-            figure_dict.get("figure_id")
-            or figure_dict.get("id")
-            or figure_dict.get("label")
-        )
-        image_path = _coerce_to_str(
-            figure_dict.get("image_path")
-            or figure_dict.get("document_relative_path")
-            or figure_dict.get("path")
-            or figure_dict.get("document_path")
-            or figure_dict.get("image")
-        )
-        description = _coerce_to_str(
-            figure_dict.get("description")
-            or figure_dict.get("caption")
-            or figure_dict.get("text")
-        )
-
-        normalized.append(
-            {
-                "figure_id": figure_id,
-                "image_path": image_path,
-                "image": image_path,
-                "description": description,
-            }
-        )
-
-    return normalized
-
-
 def _dataset_features() -> Features:
     return Features(
         {
@@ -204,8 +138,14 @@ def _dataset_features() -> Features:
             "source_image_path": HfImage(),
             "document_with_boxes_image_path": HfImage(),
             "document_markdown_text": Value("string"),
-            "figures": Sequence(HfImage()),
-            "figures_metadata": Sequence(Value("string")),
+            "figure_images": Sequence(HfImage()),
+            "figures": Sequence(
+                {
+                    "figure_id": Value("string"),
+                    "image_path": Value("string"),
+                    "description": Value("string"),
+                }
+            ),
             "document_markdown_path": Value("string"),
             "document_final_markdown_path": Value("string"),
             "document_final_markdown_text": Value("string"),
@@ -218,59 +158,52 @@ def _dataset_path(base_dir: Path) -> Path:
     return base_dir / DATASET_FILENAME
 
 
-def _build_dataset_records(documents: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-    records: List[Dict[str, Any]] = []
+def _build_dataset_records_iter(documents: Iterable[Dict[str, Any]]) -> Iterable[Dict[str, Any]]:
     for doc in documents:
-        figures = _normalize_figures(doc.get("figures", []))
-
-        document_with_boxes_relpath = _coerce_to_str(doc.get("document_with_boxes_path"))
-        if document_with_boxes_relpath:
-            relpath_obj = Path(document_with_boxes_relpath)
-            if relpath_obj.suffix.lower() != ".png":
-                document_with_boxes_relpath = relpath_obj.with_suffix(".png").as_posix()
+        document_with_boxes_path = doc.get("document_with_boxes_path") 
+        document_with_boxes_relpath = str(document_with_boxes_path) 
 
+        figure_images: List[str] = []
         figure_entries: List[Dict[str, Any]] = []
-        figure_metadata_json: List[str] = []
-        for figure in figures:
-            figure_image_relpath = _coerce_to_str(
-                figure.get("image")
-                or figure.get("image_path")
-                or figure.get("document_relative_path")
-                or figure.get("path")
+        for figure in doc.get("figures") or []:
+            if not isinstance(figure, dict):
+                continue
+
+            raw_image_path = figure.get("image_path")
+            image_relpath = str(raw_image_path)
+
+            figure_images.append(image_relpath)
+            figure_entries.append(
+                {
+                    "figure_id": str(figure.get("figure_id")),
+                    "image_path": image_relpath,
+                    "description": str(figure.get("description")),
+                    
+                }
             )
-            if figure_image_relpath:
-                figure_relpath_obj = Path(figure_image_relpath)
-                if figure_relpath_obj.suffix.lower() != ".png":
-                    figure_image_relpath = figure_relpath_obj.with_suffix(".png").as_posix()
-            metadata_entry = {
-                "figure_id": _coerce_to_str(figure.get("figure_id")),
-                "image_path": figure_image_relpath,
-                "description": _coerce_to_str(figure.get("description")),
-            }
-            figure_entries.append({**metadata_entry, "image": figure_image_relpath})
-            figure_metadata_json.append(json.dumps(metadata_entry, ensure_ascii=False))
+        yield {
+            "sample_id": str(doc.get("sample_id")),
+            "dataset_index": int(doc.get("dataset_index")),
+            "source_image_path": str(doc.get("source_image_path")),
+            "document_with_boxes_image_path": document_with_boxes_relpath,
+            "document_markdown_text": doc.get("document_markdown_text"),
+            "figure_images": figure_images,
+            "figures": figure_entries,
+            "document_markdown_path": str(doc.get("document_path")),
+            "document_final_markdown_path": str(doc.get("document_final_markdown_path")),
+            "document_final_markdown_text": doc.get("document_final_markdown_text"),
+            "raw_response_path": str(doc.get("raw_response_path")),
+        }
 
-        records.append(
-            {
-                "sample_id": doc.get("sample_id", ""),
-                "dataset_index": int(doc.get("dataset_index") or 0),
-                "source_image_path": doc.get("source_image_path", ""),
-                "document_with_boxes_image_path": document_with_boxes_relpath,
-                "document_markdown_text": doc.get("document_markdown_text") or "",
-                "figures": figure_entries,
-                "figures_metadata": figure_metadata_json,
-                "document_markdown_path": doc.get("document_path", ""),
-                "document_final_markdown_path": doc.get("document_final_markdown_path") or "",
-                "document_final_markdown_text": doc.get("document_final_markdown_text") or "",
-                "raw_response_path": doc.get("raw_response_path", ""),
-            }
-        )
-    return records
+
+def _build_dataset_records(documents: Iterable[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    return list(_build_dataset_records_iter(documents))
 
 
 def _push_dataset_records(
     *,
-    records: List[Dict[str, Any]],
+    records: Optional[Iterable[Dict[str, Any]]] = None,
+    records_path: Optional[Path] = None,
     output_dir: Path,
     repo_id: Optional[str],
     commit_message: Optional[str],
@@ -280,133 +213,39 @@ def _push_dataset_records(
         return
 
     dataset_path = _dataset_path(output_dir)
-    write_jsonl(dataset_path, records)
-
-    normalized_records: List[Dict[str, Any]] = []
-    for record in records:
-        if not isinstance(record, dict):
-            LOGGER.warning(
-                "Skipping dataset record during normalization | type=%s | value=%r",
-                type(record),
-                record,
-            )
-            continue
-        
-        print(record)
 
-        sample_id = _coerce_to_str(record.get("sample_id", ""))
-        try:
-            dataset_index = int(record.get("dataset_index") or 0)
-        except Exception:
-            LOGGER.warning(
-                "Unable to coerce dataset_index for sample %s; defaulting to 0 | value=%r",
-                sample_id or "<unknown>",
-                record.get("dataset_index"),
-            )
-            dataset_index = 0
-
-        document_with_boxes_image_path = _resolve_image_path(
-            output_dir,
-            record.get("document_with_boxes_image_path")
-            or record.get("document_with_boxes_path")
-        )
-        source_image_path = _resolve_image_path(
-            output_dir,
-            record.get("source_image_path")
-        )
-
-        figure_images: List[str] = []
-        figure_metadata_json: List[str] = []
-
-        raw_figures = record.get("figures", []) or []
-        if isinstance(raw_figures, dict):
-            raw_figures = [raw_figures]
-
-        for figure in raw_figures:
-            raw_figure_path = _coerce_to_str(
-                (figure or {}).get("image")
-                or (figure or {}).get("image_path")
-                or (figure or {}).get("document_relative_path")
-                or (figure or {}).get("path")
-            )
-            if not raw_figure_path:
-                LOGGER.warning(
-                    "Skipping figure with missing image reference | sample=%s | figure=%s",
-                    sample_id or "<unknown>",
-                    (figure or {}).get("figure_id"),
-                )
-                continue
-
-            resolved_path = _resolve_image_path(output_dir, raw_figure_path)
-            figure_images.append(resolved_path)
+    if records_path:
+        if records is not None:
+            LOGGER.warning("Both records and records_path provided; ignoring in-memory records.")
+        if records_path != dataset_path:
+            dataset_path.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copyfile(records_path, dataset_path)
+    else:
+        if records is None:
+            records = []
 
-            metadata_entry = {
-                "figure_id": _coerce_to_str((figure or {}).get("figure_id")),
-                "image_path": _coerce_to_str((figure or {}).get("image_path") or raw_figure_path),
-                "description": _coerce_to_str((figure or {}).get("description")),
-            }
-            figure_metadata_json.append(json.dumps(metadata_entry, ensure_ascii=False))
-
-        if not figure_images and record.get("figures_metadata"):
-            for metadata in record.get("figures_metadata", []):
-                parsed: Dict[str, Any]
-                if isinstance(metadata, str):
-                    try:
-                        parsed = json.loads(metadata)
-                    except Exception:
-                        LOGGER.warning(
-                            "Unable to parse figure metadata JSON | sample=%s | value=%r",
-                            sample_id or "<unknown>",
-                            metadata,
-                        )
-                        continue
-                elif isinstance(metadata, dict):
-                    parsed = metadata
+        def _record_iterator() -> Iterable[Dict[str, Any]]:
+            for record in records:
+                if isinstance(record, dict):
+                    data = dict(record)
                 else:
-                    continue
+                    data = dict(record)
 
-                raw_figure_path = _coerce_to_str(
-                    parsed.get("image_path")
-                    or parsed.get("image")
-                    or ""
-                )
-                if not raw_figure_path:
-                    continue
-                resolved_path = _resolve_image_path(output_dir, raw_figure_path)
-                figure_images.append(resolved_path)
+                if "figure_images" not in data or data["figure_images"] is None:
+                    figure_images = []
+                    for fig in data.get("figures", []) or []:
+                        if isinstance(fig, dict):
+                            image_path = fig.get("image_path")
+                            if image_path:
+                                figure_images.append(str(image_path))
+                    data["figure_images"] = figure_images
 
-                normalized_metadata = {
-                    "figure_id": _coerce_to_str(parsed.get("figure_id")),
-                    "image_path": _coerce_to_str(parsed.get("image_path") or raw_figure_path),
-                    "description": _coerce_to_str(parsed.get("description")),
-                }
-                figure_metadata_json.append(json.dumps(normalized_metadata, ensure_ascii=False))
+                yield data
 
-        normalized_records.append(
-            {
-                "sample_id": sample_id,
-                "dataset_index": dataset_index,
-                "document_markdown_path": _coerce_to_str(
-                    record.get("document_markdown_path") or record.get("document_path")
-                ),
-                "document_markdown_text": _coerce_to_str(
-                    record.get("document_markdown_text")
-                ),
-                "document_final_markdown_path": _coerce_to_str(
-                    record.get("document_final_markdown_path")
-                ),
-                "document_final_markdown_text": _coerce_to_str(
-                    record.get("document_final_markdown_text")
-                ),
-                "document_with_boxes_image_path": document_with_boxes_image_path,
-                "raw_response_path": _coerce_to_str(record.get("raw_response_path")),
-                "source_image_path": source_image_path,
-                "figures": figure_images,
-                "figures_metadata": figure_metadata_json,
-            }
-        )
+        write_jsonl_iter(dataset_path, _record_iterator())
+
+    dataset = Dataset.from_json(str(dataset_path), features=_dataset_features())
 
-    dataset = Dataset.from_list(normalized_records, features=_dataset_features())
     token = env_or_none("HF_TOKEN")
     dataset.push_to_hub(
         repo_id=repo_id,
@@ -426,7 +265,10 @@ def _load_dataset_records(path: Path) -> List[Dict[str, Any]]:
             if not line:
                 continue
             record = json.loads(line)
-            record["figures"] = _normalize_figures(record.get("figures", []))
+            if record.get("figures") is None:
+                record["figures"] = []
+            if record.get("figure_images") is None:
+                record["figure_images"] = []
             records.append(record)
     return records
 
@@ -467,7 +309,11 @@ def run_stage_extract(settings: ExtractSettings) -> None:
 
     settings.output_dir.mkdir(parents=True, exist_ok=True)
 
-    documents: List[DocumentMetadata] = []
+    documents_jsonl_path = settings.output_dir / "documents.jsonl"
+    if documents_jsonl_path.exists():
+        documents_jsonl_path.unlink()
+
+    document_count = 0
     failures: List[Dict[str, Any]] = []
 
     chunk_size = max(settings.inference.max_batch_size, 1)
@@ -516,16 +362,20 @@ def run_stage_extract(settings: ExtractSettings) -> None:
                 len(batch_contexts),
             )
 
+        batch_document_dicts: List[Dict[str, Any]] = []
+
         for idx, ctx in enumerate(batch_contexts):
             image_obj = ctx.get("image")
             try:
                 response_text = responses[idx].strip() if idx < len(responses) else ""
                 if not response_text:
                     raise RuntimeError("Empty response from DeepSeek inference")
-
+                
+                #write raw response markdown to file
                 raw_response_path = ctx["sample_dir"] / "raw_response.md"
                 write_text(raw_response_path, response_text)
 
+                #build document markdown and extract figures
                 markdown, figures, img_draw = build_document_markdown(
                     image=image_obj,
                     response_text=response_text,
@@ -533,25 +383,27 @@ def run_stage_extract(settings: ExtractSettings) -> None:
                     sample_id=ctx["sample_id"],
                 )
 
+                #write document markdown to file
                 document_path = ctx["sample_dir"] / "document.md"
                 write_text(document_path, markdown)
 
+                #write document with boxes image to file
                 img_draw.save(ctx["sample_dir"] / "document_with_boxes.png")
 
-                documents.append(
-                    DocumentMetadata(
-                        sample_id=ctx["sample_id"],
-                        dataset_index=ctx["dataset_index"],
-                        document_path=(Path(ctx["sample_id"]) / "document.md").as_posix(),
-                        raw_response_path=(Path(ctx["sample_id"]) / "raw_response.md").as_posix(),
-                        source_image_path=(Path(ctx["sample_id"]) / "source.png").as_posix(),
-                        document_with_boxes_path=(Path(ctx["sample_id"]) / "document_with_boxes.png").as_posix(),
-                        document_markdown_text=markdown,
-                        document_final_markdown_path="",
-                        document_final_markdown_text="",
-                        figures=figures,
-                    )
+                #build document metadata
+                doc_metadata = DocumentMetadata(
+                    sample_id=ctx["sample_id"],
+                    dataset_index=ctx["dataset_index"],
+                    document_path=(Path(ctx["sample_id"]) / "document.md").as_posix(),
+                    raw_response_path=(Path(ctx["sample_id"]) / "raw_response.md").as_posix(),
+                    source_image_path=(Path(ctx["sample_id"]) / "source.png").as_posix(),
+                    document_with_boxes_path=(Path(ctx["sample_id"]) / "document_with_boxes.png").as_posix(),
+                    document_markdown_text=markdown,
+                    document_final_markdown_path="",
+                    document_final_markdown_text="",
+                    figures=figures,
                 )
+                batch_document_dicts.append(dataclass_to_dict(doc_metadata))
 
                 LOGGER.debug(
                     "Processed sample %s | figures=%s | markdown_chars=%s",
@@ -573,6 +425,11 @@ def run_stage_extract(settings: ExtractSettings) -> None:
                 if hasattr(image_obj, "close"):
                     image_obj.close()
 
+        if batch_document_dicts:
+            append_jsonl(documents_jsonl_path, batch_document_dicts)
+            document_count += len(batch_document_dicts)
+
+        #reset batch contexts and requests
         batch_contexts = []
         batch_requests = []
 
@@ -586,29 +443,16 @@ def run_stage_extract(settings: ExtractSettings) -> None:
 
         raw_image = sample["images"][0]
         image = raw_image.copy()
-        # if isinstance(raw_image, Image.Image):
-        #     image = raw_image.copy()
-        # else:
-        #     image = Image.fromarray(raw_image)
-
-        # if hasattr(raw_image, "close"):
-        #     try:
-        #         raw_image.close()
-        #     except Exception:  # pragma: no cover - defensive cleanup
-        #         pass
-
         if image.mode != "RGB":
             image = image.convert("RGB")
 
+        #write source image to file
         source_image_path = sample_dir / "source.png"
         image.save(source_image_path)
 
+        #copy image for processing
         processing_image = image.copy()
-        if hasattr(image, "close"):
-            try:
-                image.close()
-            except Exception:  # pragma: no cover - defensive cleanup
-                pass
+        image.close()
 
         batch_contexts.append(
             {
@@ -631,6 +475,7 @@ def run_stage_extract(settings: ExtractSettings) -> None:
         if len(batch_requests) >= chunk_size:
             flush_batch()
 
+    #process batch if not empty
     flush_batch()
 
     manifest = {
@@ -655,7 +500,9 @@ def run_stage_extract(settings: ExtractSettings) -> None:
             "retry_backoff_seconds": settings.inference.retry_backoff_seconds,
             "max_retry_wait_seconds": settings.inference.max_retry_wait_seconds,
         },
-        "documents": [dataclass_to_dict(document) for document in documents],
+        "documents": [],
+        "documents_path": documents_jsonl_path.name,
+        "documents_count": document_count,
         "failures": failures,
     }
 
@@ -663,9 +510,10 @@ def run_stage_extract(settings: ExtractSettings) -> None:
     extract_commit = settings.upload_commit_message
     if settings.upload_repo_id and not extract_commit:
         extract_commit = f"Upload extract stage outputs {__now_iso()}"
-    dataset_records = _build_dataset_records(manifest["documents"])
+    documents_iter_for_push = iter_jsonl(documents_jsonl_path)
+    dataset_records_iter = _build_dataset_records_iter(documents_iter_for_push)
     _push_dataset_records(
-        records=dataset_records,
+        records=dataset_records_iter,
         output_dir=settings.output_dir,
         repo_id=settings.upload_repo_id,
         commit_message=extract_commit,
@@ -680,7 +528,7 @@ def run_stage_extract(settings: ExtractSettings) -> None:
     )
     LOGGER.info(
         "Extract stage complete | documents=%s | failures=%s",
-        len(documents),
+        document_count,
         len(failures),
     )
 
@@ -694,7 +542,12 @@ def run_stage_describe(settings: DescribeSettings) -> None:
         raise FileNotFoundError(f"Stage 1 manifest not found at {manifest_path}")
 
     manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
-    documents = manifest.get("documents", [])
+    documents_path_str = manifest.get("documents_path")
+    if documents_path_str:
+        documents_path = stage1_dir / documents_path_str
+        documents = read_jsonl(documents_path)
+    else:
+        documents = manifest.get("documents", []) or []
     doc_by_sample: Dict[str, Dict[str, Any]] = {doc.get("sample_id", ""): doc for doc in documents}
 
     dataset_path = _dataset_path(stage1_dir)
@@ -985,12 +838,6 @@ def run_stage_assemble(settings: AssembleSettings) -> None:
         commit_message=assemble_commit,
         revision=settings.dataset_branch,
     )
-    publish_dataset_viewer_assets(
-        dataset_records=dataset_records,
-        repo_id=settings.dataset_repo_id,
-        revision=settings.dataset_branch,
-        commit_message=f"{assemble_commit} [dataset viewer]",
-    )
     maybe_upload_dataset(
         output_dir=stage1_dir,
         repo_id=settings.dataset_repo_id,
@@ -1052,97 +899,6 @@ def __now_iso() -> str:
 
     return datetime.utcnow().isoformat() + "Z"
 
-
-def publish_dataset_viewer_assets(
-    *,
-    dataset_records: List[Dict[str, Any]],
-    repo_id: Optional[str],
-    revision: Optional[str],
-    commit_message: str,
-) -> None:
-    if not repo_id:
-        return
-
-    normalized: List[Dict[str, Any]] = []
-    for record in dataset_records:
-        figures = record.get("figures", []) or []
-        figures_metadata = record.get("figures_metadata", []) or []
-
-        viewer_figures: List[Dict[str, Any]] = []
-
-        if figures_metadata:
-            for metadata in figures_metadata:
-                if isinstance(metadata, str):
-                    try:
-                        parsed = json.loads(metadata)
-                    except Exception:
-                        LOGGER.warning(
-                            "Failed to parse figures_metadata entry for viewer | sample=%s | value=%r",
-                            record.get("sample_id"),
-                            metadata,
-                        )
-                        continue
-                elif isinstance(metadata, dict):
-                    parsed = metadata
-                else:
-                    continue
-
-                viewer_figures.append(
-                    {
-                        "figure_id": str(parsed.get("figure_id", "")),
-                        "image_path": str(parsed.get("image_path", "")),
-                        "image": str(parsed.get("image") or parsed.get("image_path") or ""),
-                        "description": parsed.get("description", ""),
-                        "metadata_json": json.dumps(parsed, ensure_ascii=False),
-                    }
-                )
-        else:
-            for fig in figures:
-                metadata = {
-                    "figure_id": _coerce_to_str(fig.get("figure_id")),
-                    "image_path": _coerce_to_str(fig.get("image_path")),
-                    "description": _coerce_to_str(fig.get("description")),
-                }
-                viewer_figures.append(
-                    {
-                        "figure_id": metadata["figure_id"],
-                        "image_path": metadata["image_path"],
-                        "image": _coerce_to_str(fig.get("image") or fig.get("image_path")),
-                        "description": metadata["description"],
-                        "metadata_json": json.dumps(metadata, ensure_ascii=False),
-                    }
-                )
-
-        normalized.append(
-            {
-                "sample_id": str(record.get("sample_id", "")),
-                "dataset_index": int(record.get("dataset_index") or 0),
-                "document_markdown_path": str(record.get("document_markdown_path", "")),
-                "document_markdown_text": record.get("document_markdown_text", ""),
-                "document_with_boxes_image": record.get("document_with_boxes_image_path"),
-                "figures": viewer_figures,
-            }
-        )
-   
-    dataset = Dataset.from_list(normalized)
-
-    token = env_or_none("HF_TOKEN")
-    try:
-        dataset.push_to_hub(
-            repo_id=repo_id,
-            token=token,
-            split="train",
-            revision=revision,
-            commit_message=commit_message,
-        )
-        LOGGER.info(
-            "Published assembled dataset viewer table | repo=%s | records=%s",
-            repo_id,
-            len(normalized),
-        )
-    except Exception as exc:  # pragma: no cover - defensive logging
-        LOGGER.exception("Failed to publish assembled dataset viewer assets: %s", exc)
-
 __all__ = [
     "run_stage_extract",
     "run_stage_describe",