Sync DeepSeek OCR HF job code

ds_batch_ocr/stages.py

@@ -208,14 +208,8 @@ def _dataset_features() -> Features:
             "document_with_boxes_image_path": HfImage(),
             "raw_response_path": Value("string"),
             "source_image_path": HfImage(),
-            "figures": Sequence(
-                {
-                    "figure_id": Value("string"),
-                    "image_path": Value("string"),
-                    "image": HfImage(),
-                    "description": Value("string"),
-                }
-            ),
+            "figures": Sequence(HfImage()),
+            "figures_metadata": Sequence(Value("string")),
         }
     )
 
@@ -236,6 +230,7 @@ def _build_dataset_records(documents: List[Dict[str, Any]]) -> List[Dict[str, An
                 document_with_boxes_relpath = relpath_obj.with_suffix(".png").as_posix()
 
         figure_entries: List[Dict[str, Any]] = []
+        figure_metadata_json: List[str] = []
         for figure in figures:
             figure_image_relpath = _coerce_to_str(
                 figure.get("image")
@@ -247,14 +242,13 @@ def _build_dataset_records(documents: List[Dict[str, Any]]) -> List[Dict[str, An
                 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()
-            figure_entries.append(
-                {
-                    "figure_id": _coerce_to_str(figure.get("figure_id")),
-                    "image_path": figure_image_relpath,
-                    "image": figure_image_relpath,
-                    "description": _coerce_to_str(figure.get("description")),
-                }
-            )
+            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))
 
         records.append(
             {
@@ -268,6 +262,7 @@ def _build_dataset_records(documents: List[Dict[str, Any]]) -> List[Dict[str, An
                 "raw_response_path": doc.get("raw_response_path", ""),
                 "source_image_path": doc.get("source_image_path", ""),
                 "figures": figure_entries,
+                "figures_metadata": figure_metadata_json,
             }
         )
     return records
@@ -319,26 +314,73 @@ def _push_dataset_records(
             output_dir,
             record.get("source_image_path")
         )
-        figure_entries: List[Dict[str, Any]] = []
-        for figure in record.get("figures", []):
-            raw_figure_path = figure.get("image") or figure.get("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.get("figure_id"),
+                    (figure or {}).get("figure_id"),
                 )
                 continue
 
-            figure_image_path = _resolve_image_path(output_dir, raw_figure_path)
-            figure_entries.append(
-                {
-                    "figure_id": _coerce_to_str(figure.get("figure_id")),
-                    "image_path": _coerce_to_str(figure.get("image_path") or raw_figure_path),
-                    "image": figure_image_path,
-                    "description": _coerce_to_str(figure.get("description")),
+            resolved_path = _resolve_image_path(output_dir, raw_figure_path)
+            figure_images.append(resolved_path)
+
+            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
+                else:
+                    continue
+
+                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)
+
+                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))
 
         normalized_records.append(
             {
@@ -359,7 +401,8 @@ def _push_dataset_records(
                 "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_entries,
+                "figures": figure_images,
+                "figures_metadata": figure_metadata_json,
             }
         )
 
@@ -1023,6 +1066,53 @@ def publish_dataset_viewer_assets(
     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", "")),
@@ -1030,15 +1120,7 @@ def publish_dataset_viewer_assets(
                 "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": [
-                    {
-                        "figure_id": str(fig.get("figure_id", "")),
-                        "image_path": str(fig.get("image_path", "")),
-                        "image": str(fig.get("image") or fig.get("image_path") or ""),
-                        "description": fig.get("description", ""),
-                    }
-                    for fig in figures
-                ],
+                "figures": viewer_figures,
             }
         )