Sync DeepSeek OCR HF job code

ds_batch_ocr/config.py

@@ -32,7 +32,7 @@ class DocumentMetadata:
     document_markdown_text: str
     document_final_markdown_path: Optional[str] = None
     document_final_markdown_text: Optional[str] = None
-    figures: List[FigureMetadata] = field(default_factory=list)
+    extracted_figures: List[FigureMetadata] = field(default_factory=list)
 
 
 @dataclass

ds_batch_ocr/stages.py

@@ -89,47 +89,6 @@ def write_jsonl_iter(path: Path, rows: Iterable[Dict[str, Any]]) -> int:
     return count
 
 
-def _resolve_image_path(base_dir: Path, value: Any) -> str:
-    if value is None:
-        return ""
-
-    if isinstance(value, (list, tuple, set)):
-        candidate = ""
-        for item in 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)
-
-    if not path_str:
-        return ""
-
-    path = Path(path_str)
-    if not path.is_absolute():
-        path = base_dir / path
-
-    if path.suffix.lower() != ".png":
-        png_candidate = path.with_suffix(".png")
-        if png_candidate.exists():
-            path = png_candidate
-
-    if not path.exists():
-        LOGGER.warning("Image asset missing when preparing dataset | path=%s", path)
-        return path.as_posix()
-
-    return path.as_posix()
-
-
 def _dataset_features() -> Features:
     return Features(
         {
@@ -138,11 +97,8 @@ def _dataset_features() -> Features:
             "source_image_path": HfImage(),
             "document_with_boxes_image_path": HfImage(),
             "document_markdown_text": Value("string"),
-            "figures": {
-                "figure_id": Sequence(Value("string")),
-                "image_path": Sequence(Value("string")),
-                "description": Sequence(Value("string")),
-            },
+            "extracted_figures": Sequence(HfImage()),
+            "extracted_figures_metadata": Sequence(Value("string")),
             "document_markdown_path": Value("string"),
             "document_final_markdown_path": Value("string"),
             "document_final_markdown_text": Value("string"),
@@ -155,61 +111,20 @@ def _dataset_path(base_dir: Path) -> Path:
     return base_dir / DATASET_FILENAME
 
 
-def _figures_to_columnar(figures: Optional[Iterable[Dict[str, Any]]]) -> Dict[str, List[str]]:
-    ids: List[str] = []
-    paths: List[str] = []
-    descriptions: List[str] = []
-
-    if figures:
-        for figure in figures:
-            if not isinstance(figure, dict):
-                continue
-
-            ids.append(str(figure.get("figure_id") or figure.get("id") or ""))
-            paths.append(str(figure.get("image_path") or ""))
-            descriptions.append(str(figure.get("description") or ""))
-
-    return {
-        "figure_id": ids,
-        "image_path": paths,
-        "description": descriptions,
-    }
-
-
-def _figures_from_columnar(figures: Optional[Dict[str, Any]]) -> List[Dict[str, str]]:
-    if not isinstance(figures, dict):
-        return []
-
-    ids = list(figures.get("figure_id") or [])
-    paths = list(figures.get("image_path") or [])
-    descriptions = list(figures.get("description") or [])
-
-    length = max(len(ids), len(paths), len(descriptions))
-    result: List[Dict[str, str]] = []
-    for idx in range(length):
-        result.append(
-            {
-                "figure_id": str(ids[idx]) if idx < len(ids) else "",
-                "image_path": str(paths[idx]) if idx < len(paths) else "",
-                "description": str(descriptions[idx]) if idx < len(descriptions) else "",
-            }
-        )
-    return result
-
 
 def _build_dataset_records_iter(documents: Iterable[Dict[str, Any]]) -> Iterable[Dict[str, Any]]:
     for doc in documents:
         document_with_boxes_path = doc.get("document_with_boxes_path") 
         document_with_boxes_relpath = str(document_with_boxes_path) 
 
-        figure_entries = _figures_to_columnar(doc.get("figures"))
         yield {
             "sample_id": str(doc.get("sample_id")),
             "dataset_index": int(doc.get("dataset_index") or 0),
             "source_image_path": str(doc.get("source_image_path") or ""),
             "document_with_boxes_image_path": document_with_boxes_relpath,
             "document_markdown_text": doc.get("document_markdown_text") or "",
-            "figures": figure_entries,
+            "extracted_figures": doc.get("extracted_figures") or [],
+            "extracted_figures_metadata": json.dumps(doc.get("extracted_figures_metadata") or []),
             "document_markdown_path": str(doc.get("document_path") or ""),
             "document_final_markdown_path": str(doc.get("document_final_markdown_path") or ""),
             "document_final_markdown_text": doc.get("document_final_markdown_text") or "",
@@ -321,9 +236,13 @@ def run_stage_extract(settings: ExtractSettings) -> None:
 
     settings.output_dir.mkdir(parents=True, exist_ok=True)
 
-    documents_jsonl_path = settings.output_dir / "documents.jsonl"
-    if documents_jsonl_path.exists():
-        documents_jsonl_path.unlink()
+    documents_batches_dir = settings.output_dir / "document_batches"
+    if documents_batches_dir.exists():
+        shutil.rmtree(documents_batches_dir)
+    documents_batches_dir.mkdir(parents=True, exist_ok=True)
+
+    document_batch_files: List[Path] = []
+    batch_index = 0
 
     document_count = 0
     failures: List[Dict[str, Any]] = []
@@ -343,7 +262,7 @@ def run_stage_extract(settings: ExtractSettings) -> None:
     batch_requests: List[Dict[str, Any]] = []
 
     def flush_batch() -> None:
-        nonlocal batch_contexts, batch_requests, document_count
+        nonlocal batch_contexts, batch_requests, document_count, batch_index
         if not batch_contexts:
             return
 
@@ -413,7 +332,7 @@ def run_stage_extract(settings: ExtractSettings) -> None:
                     document_markdown_text=markdown,
                     document_final_markdown_path="",
                     document_final_markdown_text="",
-                    figures=figures,
+                    extracted_figures=figures,
                 )
                 batch_document_dicts.append(dataclass_to_dict(doc_metadata))
 
@@ -438,7 +357,10 @@ def run_stage_extract(settings: ExtractSettings) -> None:
                     image_obj.close()
 
         if batch_document_dicts:
-            append_jsonl(documents_jsonl_path, batch_document_dicts)
+            batch_file = documents_batches_dir / f"batch_{batch_index:05d}.json"
+            write_json(batch_file, batch_document_dicts)
+            document_batch_files.append(batch_file)
+            batch_index += 1
             document_count += len(batch_document_dicts)
 
         #reset batch contexts and requests
@@ -513,24 +435,34 @@ def run_stage_extract(settings: ExtractSettings) -> None:
             "max_retry_wait_seconds": settings.inference.max_retry_wait_seconds,
         },
         "documents": [],
-        "documents_path": documents_jsonl_path.name,
+        "documents_path": documents_batches_dir.name,
+        "documents_batches": [
+            file.relative_to(settings.output_dir).as_posix() for file in document_batch_files
+        ],
         "documents_count": document_count,
         "failures": failures,
     }
 
     write_json(settings.output_dir / "manifest.json", manifest)
-    maybe_upload_dataset(
-        output_dir=settings.output_dir,
-        repo_id=settings.upload_repo_id,
-        path_in_repo=settings.upload_path_in_repo,
-        commit_message=extract_commit,
-        revision=settings.upload_revision,
-    )
-    
     extract_commit = settings.upload_commit_message
     if settings.upload_repo_id and not extract_commit:
         extract_commit = f"Upload extract stage outputs {__now_iso()}"
-    documents_iter_for_push = iter_jsonl(documents_jsonl_path)
+    def iter_documents_from_batches(files: Iterable[Path]) -> Iterable[Dict[str, Any]]:
+        for file_path in files:
+            try:
+                batch_data = json.loads(file_path.read_text(encoding="utf-8"))
+            except Exception as exc:  # pragma: no cover - defensive logging
+                LOGGER.warning("Failed to read documents batch %s: %s", file_path, exc)
+                continue
+
+            if not isinstance(batch_data, list):
+                LOGGER.warning("Unexpected batch content in %s; expected list", file_path)
+                continue
+
+            for entry in batch_data:
+                yield entry
+
+    documents_iter_for_push = iter_documents_from_batches(document_batch_files)
     dataset_records_iter = _build_dataset_records_iter(documents_iter_for_push)
     _push_dataset_records(
         records=dataset_records_iter,
@@ -562,12 +494,29 @@ 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_path_str = manifest.get("documents_path")
-    if documents_path_str:
-        documents_path = stage1_dir / documents_path_str
-        documents = read_jsonl(documents_path)
+
+    documents: List[Dict[str, Any]] = []
+    batch_rel_paths = manifest.get("documents_batches") or []
+    if batch_rel_paths:
+        for rel in batch_rel_paths:
+            batch_path = stage1_dir / rel
+            try:
+                batch_data = json.loads(batch_path.read_text(encoding="utf-8"))
+            except Exception as exc:  # pragma: no cover
+                LOGGER.warning("Failed to load document batch %s: %s", batch_path, exc)
+                continue
+
+            if isinstance(batch_data, list):
+                documents.extend(batch_data)
+            else:
+                LOGGER.warning("Unexpected document batch format at %s", batch_path)
     else:
-        documents = manifest.get("documents", []) or []
+        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)