mirror of
https://github.com/lllin000/PaperForge.git
synced 2026-07-22 06:50:53 +00:00
570 lines
19 KiB
Python
570 lines
19 KiB
Python
from pathlib import Path
|
|
|
|
|
|
def test_ocr_redo_papers_dry_run_no_changes(tmp_path):
|
|
from paperforge.worker.ocr import ocr_redo_papers
|
|
|
|
vault = tmp_path / "vault"
|
|
vault.mkdir()
|
|
literature = vault / "Resources" / "Literature" / "test_domain"
|
|
literature.mkdir(parents=True)
|
|
|
|
note = literature / "test note.md"
|
|
note.write_text(
|
|
"""---
|
|
zotero_key: "ABCD1234"
|
|
title: "Test"
|
|
ocr_redo: true
|
|
ocr_status: done
|
|
fulltext_md_path: "[[old_path]]"
|
|
---
|
|
""",
|
|
encoding="utf-8",
|
|
)
|
|
|
|
ocr_root = vault / "System" / "PaperForge" / "ocr"
|
|
ocr_root.mkdir(parents=True)
|
|
ocr_dir = ocr_root / "ABCD1234"
|
|
ocr_dir.mkdir()
|
|
(ocr_dir / "fulltext.md").write_text("old ocr content")
|
|
|
|
rc = ocr_redo_papers(vault, dry_run=True, verbose=True)
|
|
assert rc == 0
|
|
|
|
content = note.read_text(encoding="utf-8")
|
|
assert "ocr_redo: true" in content
|
|
assert (ocr_dir / "fulltext.md").exists()
|
|
|
|
|
|
def test_ocr_redo_papers_invalid_key_rejected(tmp_path):
|
|
from paperforge.worker.ocr import ocr_redo_papers
|
|
|
|
vault = tmp_path / "vault"
|
|
vault.mkdir()
|
|
literature = vault / "Resources" / "Literature" / "test_domain"
|
|
literature.mkdir(parents=True)
|
|
|
|
note = literature / "bad key.md"
|
|
note.write_text("""---
|
|
zotero_key: "../../../etc/passwd"
|
|
title: "Evil"
|
|
ocr_redo: true
|
|
---
|
|
""")
|
|
|
|
rc = ocr_redo_papers(vault, dry_run=False, verbose=True)
|
|
assert rc == 0
|
|
content = note.read_text(encoding="utf-8")
|
|
assert "ocr_redo: true" in content # Never touched
|
|
|
|
|
|
def test_ocr_redo_papers_updates_frontmatter(tmp_path):
|
|
from paperforge.worker import ocr as ocr_worker
|
|
|
|
vault = tmp_path / "vault"
|
|
vault.mkdir()
|
|
literature = vault / "Resources" / "Literature" / "test_domain"
|
|
literature.mkdir(parents=True)
|
|
|
|
workspace = literature / "AB12CD34 - Test"
|
|
workspace.mkdir()
|
|
note = workspace / "AB12CD34.md"
|
|
note.write_text(
|
|
"""---
|
|
zotero_key: "AB12CD34"
|
|
title: "Test"
|
|
ocr_redo: true
|
|
do_ocr: false
|
|
ocr_status: done
|
|
fulltext_md_path: "[[old_path]]"
|
|
---
|
|
""",
|
|
encoding="utf-8",
|
|
)
|
|
|
|
(workspace / "fulltext.md").write_text("old workspace copy\n", encoding="utf-8")
|
|
|
|
ocr_root = vault / "System" / "PaperForge" / "ocr"
|
|
ocr_root.mkdir(parents=True)
|
|
ocr_dir = ocr_root / "AB12CD34"
|
|
ocr_dir.mkdir()
|
|
(ocr_dir / "fulltext.md").write_text("old canonical content\n", encoding="utf-8")
|
|
|
|
calls = {}
|
|
|
|
def fake_run_ocr(vault_arg, verbose=False, no_progress=False, selected_keys=None):
|
|
calls["selected_keys"] = selected_keys
|
|
new_dir = ocr_root / "AB12CD34"
|
|
(new_dir / "json").mkdir(parents=True, exist_ok=True)
|
|
fulltext = "<!-- page 1 -->\n" + ("A" * 700)
|
|
(new_dir / "fulltext.md").write_text(fulltext, encoding="utf-8")
|
|
(new_dir / "json" / "result.json").write_text("{" + ('"x":1,' * 600) + '"done":true}', encoding="utf-8")
|
|
(new_dir / "meta.json").write_text(
|
|
'{"zotero_key":"AB12CD34","ocr_status":"done","page_count":1,"fulltext_md_path":"",'
|
|
'"markdown_path":"System/PaperForge/ocr/AB12CD34/fulltext.md","json_path":"System/PaperForge/ocr/AB12CD34/json/result.json"}',
|
|
encoding="utf-8",
|
|
)
|
|
return 0
|
|
|
|
monkeypatch = __import__("pytest").MonkeyPatch()
|
|
monkeypatch.setattr(ocr_worker, "run_ocr", fake_run_ocr)
|
|
monkeypatch.setattr(ocr_worker, "refresh_index_entry", lambda _vault, _key: None)
|
|
|
|
try:
|
|
rc = ocr_worker.ocr_redo_papers(vault, dry_run=False, verbose=True)
|
|
assert rc == 0
|
|
finally:
|
|
monkeypatch.undo()
|
|
|
|
content = note.read_text(encoding="utf-8")
|
|
assert "ocr_redo: false" in content
|
|
assert 'ocr_status: "done"' in content
|
|
assert 'fulltext_md_path: ""' in content
|
|
assert "do_ocr: true" in content
|
|
assert calls["selected_keys"] == {"AB12CD34"}
|
|
assert not (workspace / "fulltext.md").exists()
|
|
|
|
|
|
def test_ocr_redo_papers_keeps_flag_true_when_rerun_not_done(tmp_path):
|
|
from paperforge.worker import ocr as ocr_worker
|
|
|
|
vault = tmp_path / "vault"
|
|
vault.mkdir()
|
|
literature = vault / "Resources" / "Literature" / "test_domain"
|
|
literature.mkdir(parents=True)
|
|
|
|
workspace = literature / "ZXCV1234 - Test"
|
|
workspace.mkdir()
|
|
note = workspace / "ZXCV1234.md"
|
|
note.write_text(
|
|
"""---
|
|
zotero_key: "ZXCV1234"
|
|
title: "Test"
|
|
ocr_redo: true
|
|
do_ocr: false
|
|
ocr_status: done
|
|
---
|
|
""",
|
|
encoding="utf-8",
|
|
)
|
|
|
|
monkeypatch = __import__("pytest").MonkeyPatch()
|
|
monkeypatch.setattr(ocr_worker, "run_ocr", lambda *_args, **_kwargs: 1)
|
|
monkeypatch.setattr(ocr_worker, "refresh_index_entry", lambda _vault, _key: None)
|
|
|
|
try:
|
|
rc = ocr_worker.ocr_redo_papers(vault, dry_run=False, verbose=True)
|
|
assert rc == 1
|
|
finally:
|
|
monkeypatch.undo()
|
|
|
|
content = note.read_text(encoding="utf-8")
|
|
assert "ocr_redo: true" in content
|
|
assert 'ocr_status: "pending"' in content
|
|
|
|
|
|
def test_ocr_redo_rebuilds_phase1_artifacts(tmp_path: Path) -> None:
|
|
"""Verify ocr redo produces all Phase 1 artifacts."""
|
|
from paperforge.worker import ocr as ocr_worker
|
|
|
|
key = "REDO0012"
|
|
vault = tmp_path / "vault"
|
|
vault.mkdir()
|
|
literature = vault / "Resources" / "Literature" / "test_domain"
|
|
literature.mkdir(parents=True)
|
|
|
|
workspace = literature / f"{key} - Test"
|
|
workspace.mkdir()
|
|
note = workspace / f"{key}.md"
|
|
note.write_text(
|
|
f"""---
|
|
zotero_key: "{key}"
|
|
title: "Test"
|
|
ocr_redo: true
|
|
do_ocr: false
|
|
ocr_status: done
|
|
fulltext_md_path: "[[old_path]]"
|
|
---
|
|
""",
|
|
encoding="utf-8",
|
|
)
|
|
|
|
(workspace / "fulltext.md").write_text("old workspace copy\n", encoding="utf-8")
|
|
|
|
ocr_root = vault / "System" / "PaperForge" / "ocr"
|
|
ocr_root.mkdir(parents=True)
|
|
ocr_dir = ocr_root / key
|
|
ocr_dir.mkdir()
|
|
(ocr_dir / "fulltext.md").write_text("old canonical content\n", encoding="utf-8")
|
|
|
|
def fake_run_ocr(vault_arg, verbose=False, no_progress=False, selected_keys=None):
|
|
new_dir = ocr_root / key
|
|
(new_dir / "json").mkdir(parents=True, exist_ok=True)
|
|
(new_dir / "raw").mkdir(parents=True, exist_ok=True)
|
|
(new_dir / "canonical").mkdir(parents=True, exist_ok=True)
|
|
(new_dir / "structure").mkdir(parents=True, exist_ok=True)
|
|
fulltext = "<!-- page 1 -->\n" + ("A" * 700)
|
|
(new_dir / "fulltext.md").write_text(fulltext, encoding="utf-8")
|
|
(new_dir / "json" / "result.json").write_text("{" + ('"x":1,' * 600) + '"done":true}', encoding="utf-8")
|
|
(new_dir / "raw" / "raw_meta.json").write_text('{"ocr_provider":"PaddleOCR"}', encoding="utf-8")
|
|
(new_dir / "raw" / "source_metadata.json").write_text(f'{{"zotero_key":"{key}"}}', encoding="utf-8")
|
|
(new_dir / "canonical" / "blocks.raw.jsonl").write_text(f'{{"paper_id":"{key}","page":1}}\n', encoding="utf-8")
|
|
(new_dir / "structure" / "blocks.structured.jsonl").write_text(
|
|
f'{{"paper_id":"{key}","role":"body_paragraph"}}\n', encoding="utf-8"
|
|
)
|
|
import json
|
|
|
|
meta = {
|
|
"zotero_key": key,
|
|
"ocr_status": "done",
|
|
"page_count": 1,
|
|
"fulltext_md_path": "",
|
|
"markdown_path": f"System/PaperForge/ocr/{key}/fulltext.md",
|
|
"json_path": f"System/PaperForge/ocr/{key}/json/result.json",
|
|
"raw_version": {"ocr_model": "PaddleOCR-VL-1.6"},
|
|
"derived_version": {"renderer_version": "1.0.0-compat"},
|
|
}
|
|
(new_dir / "meta.json").write_text(json.dumps(meta), encoding="utf-8")
|
|
return 0
|
|
|
|
monkeypatch = __import__("pytest").MonkeyPatch()
|
|
monkeypatch.setattr(ocr_worker, "run_ocr", fake_run_ocr)
|
|
monkeypatch.setattr(ocr_worker, "refresh_index_entry", lambda _vault, _key: None)
|
|
|
|
try:
|
|
rc = ocr_worker.ocr_redo_papers(vault, dry_run=False, verbose=True)
|
|
assert rc == 0
|
|
finally:
|
|
monkeypatch.undo()
|
|
|
|
# Verify Phase 1 artifacts exist after redo
|
|
assert (ocr_dir / "json" / "result.json").exists()
|
|
assert (ocr_dir / "raw" / "raw_meta.json").exists()
|
|
assert (ocr_dir / "canonical" / "blocks.raw.jsonl").exists()
|
|
assert (ocr_dir / "structure" / "blocks.structured.jsonl").exists()
|
|
|
|
# Verify compatibility outputs still exist
|
|
assert (ocr_dir / "fulltext.md").exists()
|
|
|
|
# Verify ocr_redo flipped to false
|
|
content = note.read_text(encoding="utf-8")
|
|
assert "ocr_redo: false" in content
|
|
|
|
|
|
def test_postprocess_preserves_compatibility_outputs(tmp_path: Path) -> None:
|
|
"""Verify that postprocess still writes compat fulltext.md and result.json."""
|
|
import json
|
|
|
|
from paperforge.worker.ocr import postprocess_ocr_result
|
|
|
|
vault = tmp_path / "vault"
|
|
vault.mkdir()
|
|
(vault / "paperforge.json").write_text(
|
|
json.dumps({"vault_config": {"system_dir": "System", "resources_dir": "Resources"}}),
|
|
encoding="utf-8",
|
|
)
|
|
ocr_root = vault / "System" / "PaperForge" / "ocr"
|
|
ocr_root.mkdir(parents=True)
|
|
ocr_dir = ocr_root / "COMPAT1"
|
|
ocr_dir.mkdir()
|
|
(ocr_dir / "meta.json").write_text('{"zotero_key":"COMPAT1","ocr_status":"done"}', encoding="utf-8")
|
|
|
|
page_num, md_path, json_path, fulltext_md_path = postprocess_ocr_result(vault, "COMPAT1", [])
|
|
|
|
assert page_num == 0
|
|
assert (ocr_dir / "fulltext.md").exists()
|
|
assert (ocr_dir / "json" / "result.json").exists()
|
|
assert isinstance(md_path, str)
|
|
assert isinstance(json_path, str)
|
|
assert isinstance(fulltext_md_path, str)
|
|
|
|
|
|
def test_postprocess_writes_phase1_artifacts(tmp_path: Path) -> None:
|
|
import json
|
|
|
|
from paperforge.worker.ocr import postprocess_ocr_result
|
|
|
|
vault = tmp_path / "vault"
|
|
vault.mkdir()
|
|
(vault / "paperforge.json").write_text(
|
|
json.dumps({"vault_config": {"system_dir": "System", "resources_dir": "Resources"}}),
|
|
encoding="utf-8",
|
|
)
|
|
ocr_root = vault / "System" / "PaperForge" / "ocr"
|
|
ocr_root.mkdir(parents=True)
|
|
ocr_dir = ocr_root / "ABCD1234"
|
|
ocr_dir.mkdir()
|
|
(ocr_dir / "meta.json").write_text(
|
|
'{"zotero_key":"ABCD1234","ocr_status":"done","ocr_model":"PaddleOCR-VL-1.6"}',
|
|
encoding="utf-8",
|
|
)
|
|
|
|
page_num, _, _, _ = postprocess_ocr_result(vault, "ABCD1234", [])
|
|
assert page_num == 0
|
|
assert (ocr_dir / "raw" / "raw_meta.json").exists()
|
|
assert (ocr_dir / "raw" / "source_metadata.json").exists()
|
|
assert (ocr_dir / "canonical" / "blocks.raw.jsonl").exists()
|
|
assert (ocr_dir / "structure" / "blocks.structured.jsonl").exists()
|
|
|
|
meta = json.loads((ocr_dir / "meta.json").read_text(encoding="utf-8"))
|
|
assert "zotero_key" in meta # original field preserved
|
|
assert "ocr_status" in meta # original field preserved
|
|
assert "raw_version" in meta
|
|
assert meta["raw_version"]["ocr_model"] == "PaddleOCR-VL-1.6"
|
|
assert "derived_version" in meta
|
|
assert "renderer_version" in meta["derived_version"]
|
|
|
|
|
|
def test_postprocess_meta_json_preserves_original_fields(tmp_path: Path) -> None:
|
|
"""Verify postprocess preserves pre-Phase-1 meta.json fields."""
|
|
import json
|
|
|
|
from paperforge.worker.ocr import postprocess_ocr_result
|
|
|
|
vault = tmp_path / "vault"
|
|
vault.mkdir()
|
|
(vault / "paperforge.json").write_text(
|
|
json.dumps({"vault_config": {"system_dir": "System", "resources_dir": "Resources"}}),
|
|
encoding="utf-8",
|
|
)
|
|
ocr_root = vault / "System" / "PaperForge" / "ocr"
|
|
ocr_root.mkdir(parents=True)
|
|
ocr_dir = ocr_root / "METAORIG"
|
|
ocr_dir.mkdir()
|
|
(ocr_dir / "meta.json").write_text(
|
|
'{"zotero_key":"METAORIG","ocr_status":"done","ocr_model":"PaddleOCR",'
|
|
'"page_count":3,"source_pdf":"nonexistent.pdf"}',
|
|
encoding="utf-8",
|
|
)
|
|
|
|
_, _, _, _ = postprocess_ocr_result(vault, "METAORIG", [])
|
|
|
|
meta = json.loads((ocr_dir / "meta.json").read_text(encoding="utf-8"))
|
|
assert meta.get("zotero_key") == "METAORIG"
|
|
assert meta.get("ocr_status") == "done"
|
|
assert meta.get("page_count") == 3
|
|
assert "raw_version" in meta
|
|
assert "derived_version" in meta
|
|
|
|
|
|
def test_postprocess_writes_resolved_metadata(tmp_path: Path) -> None:
|
|
import json
|
|
|
|
from paperforge.worker.ocr import postprocess_ocr_result
|
|
|
|
vault = tmp_path / "vault"
|
|
vault.mkdir()
|
|
(vault / "paperforge.json").write_text(
|
|
json.dumps({"vault_config": {"system_dir": "System", "resources_dir": "Resources"}}),
|
|
encoding="utf-8",
|
|
)
|
|
ocr_root = vault / "System" / "PaperForge" / "ocr"
|
|
ocr_root.mkdir(parents=True)
|
|
ocr_dir = ocr_root / "META001"
|
|
ocr_dir.mkdir()
|
|
(ocr_dir / "meta.json").write_text(
|
|
'{"zotero_key":"META001","ocr_status":"done","ocr_model":"PaddleOCR"}',
|
|
encoding="utf-8",
|
|
)
|
|
|
|
_, _, _, _ = postprocess_ocr_result(vault, "META001", [])
|
|
|
|
assert (ocr_dir / "raw" / "raw_meta.json").exists()
|
|
assert (ocr_dir / "raw" / "source_metadata.json").exists()
|
|
# Phase 2: resolved_metadata.json does not exist yet — this test will fail
|
|
# The assertion goes here as a contract test
|
|
assert (ocr_dir / "metadata" / "resolved_metadata.json").exists()
|
|
|
|
|
|
def test_postprocess_writes_figure_inventory(tmp_path: Path) -> None:
|
|
import json
|
|
|
|
from paperforge.worker.ocr import postprocess_ocr_result
|
|
|
|
vault = tmp_path / "vault"
|
|
vault.mkdir()
|
|
(vault / "paperforge.json").write_text(
|
|
json.dumps({"vault_config": {"system_dir": "System", "resources_dir": "Resources"}}),
|
|
encoding="utf-8",
|
|
)
|
|
ocr_root = vault / "System" / "PaperForge" / "ocr"
|
|
ocr_root.mkdir(parents=True)
|
|
ocr_dir = ocr_root / "FIG001"
|
|
ocr_dir.mkdir()
|
|
(ocr_dir / "meta.json").write_text(
|
|
'{"zotero_key":"FIG001","ocr_status":"done","ocr_model":"PaddleOCR"}',
|
|
encoding="utf-8",
|
|
)
|
|
|
|
_, _, _, _ = postprocess_ocr_result(vault, "FIG001", [])
|
|
|
|
# Phase 2: figure_inventory.json does not exist yet -- test will fail
|
|
assert (ocr_dir / "structure" / "figure_inventory.json").exists()
|
|
|
|
|
|
def test_postprocess_writes_table_inventory(tmp_path: Path) -> None:
|
|
import json
|
|
|
|
from paperforge.worker.ocr import postprocess_ocr_result
|
|
|
|
vault = tmp_path / "vault"
|
|
vault.mkdir()
|
|
(vault / "paperforge.json").write_text(
|
|
json.dumps({"vault_config": {"system_dir": "System", "resources_dir": "Resources"}}),
|
|
encoding="utf-8",
|
|
)
|
|
ocr_root = vault / "System" / "PaperForge" / "ocr"
|
|
ocr_root.mkdir(parents=True)
|
|
ocr_dir = ocr_root / "TBL001"
|
|
ocr_dir.mkdir()
|
|
(ocr_dir / "meta.json").write_text(
|
|
'{"zotero_key":"TBL001","ocr_status":"done","ocr_model":"PaddleOCR"}',
|
|
encoding="utf-8",
|
|
)
|
|
|
|
_, _, _, _ = postprocess_ocr_result(vault, "TBL001", [])
|
|
|
|
# Phase 2: table_inventory.json does not exist yet -- will fail
|
|
assert (ocr_dir / "structure" / "table_inventory.json").exists()
|
|
|
|
|
|
def test_postprocess_creates_object_directories(tmp_path: Path) -> None:
|
|
"""Verify postprocess creates object directories even with empty results."""
|
|
import json
|
|
|
|
from paperforge.worker.ocr import postprocess_ocr_result
|
|
|
|
vault = tmp_path / "vault"
|
|
vault.mkdir()
|
|
(vault / "paperforge.json").write_text(
|
|
json.dumps({"vault_config": {"system_dir": "System", "resources_dir": "Resources"}}),
|
|
encoding="utf-8",
|
|
)
|
|
ocr_root = vault / "System" / "PaperForge" / "ocr"
|
|
ocr_root.mkdir(parents=True)
|
|
ocr_dir = ocr_root / "OBJ001"
|
|
ocr_dir.mkdir()
|
|
(ocr_dir / "meta.json").write_text(
|
|
'{"zotero_key":"OBJ001","ocr_status":"done","ocr_model":"PaddleOCR"}',
|
|
encoding="utf-8",
|
|
)
|
|
|
|
_, _, _, _ = postprocess_ocr_result(vault, "OBJ001", [])
|
|
|
|
# Phase 2: object artifact directories are created during postprocess
|
|
assert (ocr_dir / "render" / "figures").exists()
|
|
assert (ocr_dir / "render" / "tables").exists()
|
|
assert (ocr_dir / "assets" / "figures").exists()
|
|
assert (ocr_dir / "assets" / "tables").exists()
|
|
assert (ocr_dir / "assets" / "orphans").exists()
|
|
|
|
|
|
def test_postprocess_writes_render_fulltext(tmp_path: Path) -> None:
|
|
import json
|
|
|
|
from paperforge.worker.ocr import postprocess_ocr_result
|
|
|
|
vault = tmp_path / "vault"
|
|
vault.mkdir()
|
|
(vault / "paperforge.json").write_text(
|
|
json.dumps({"vault_config": {"system_dir": "System", "resources_dir": "Resources"}}),
|
|
encoding="utf-8",
|
|
)
|
|
ocr_root = vault / "System" / "PaperForge" / "ocr"
|
|
ocr_root.mkdir(parents=True)
|
|
ocr_dir = ocr_root / "RNDR001"
|
|
ocr_dir.mkdir()
|
|
(ocr_dir / "meta.json").write_text(
|
|
'{"zotero_key":"RNDR001","ocr_status":"done","ocr_model":"PaddleOCR"}',
|
|
encoding="utf-8",
|
|
)
|
|
|
|
_, _, _, _ = postprocess_ocr_result(vault, "RNDR001", [])
|
|
|
|
# Phase 3: render/fulltext.md does not exist yet -- this test will fail
|
|
assert (ocr_dir / "render" / "fulltext.md").exists()
|
|
|
|
|
|
def test_postprocess_writes_ocr_health(tmp_path: Path) -> None:
|
|
import json
|
|
|
|
from paperforge.worker.ocr import postprocess_ocr_result
|
|
|
|
vault = tmp_path / "vault"
|
|
vault.mkdir()
|
|
(vault / "paperforge.json").write_text(
|
|
json.dumps({"vault_config": {"system_dir": "System", "resources_dir": "Resources"}}),
|
|
encoding="utf-8",
|
|
)
|
|
ocr_root = vault / "System" / "PaperForge" / "ocr"
|
|
ocr_root.mkdir(parents=True)
|
|
ocr_dir = ocr_root / "HLTH001"
|
|
ocr_dir.mkdir()
|
|
(ocr_dir / "meta.json").write_text(
|
|
'{"zotero_key":"HLTH001","ocr_status":"done","ocr_model":"PaddleOCR"}',
|
|
encoding="utf-8",
|
|
)
|
|
|
|
_, _, _, _ = postprocess_ocr_result(vault, "HLTH001", [])
|
|
|
|
# Phase 3: health/ocr_health.json does not exist yet -- this test will fail
|
|
assert (ocr_dir / "health" / "ocr_health.json").exists()
|
|
|
|
|
|
def test_version_state_classifiable_from_meta_json(tmp_path: Path) -> None:
|
|
import json
|
|
|
|
from paperforge.worker.ocr import postprocess_ocr_result
|
|
|
|
vault = tmp_path / "vault"
|
|
vault.mkdir()
|
|
(vault / "paperforge.json").write_text(
|
|
json.dumps({"vault_config": {"system_dir": "System", "resources_dir": "Resources"}}),
|
|
encoding="utf-8",
|
|
)
|
|
ocr_root = vault / "System" / "PaperForge" / "ocr"
|
|
ocr_root.mkdir(parents=True)
|
|
ocr_dir = ocr_root / "VST001"
|
|
ocr_dir.mkdir()
|
|
(ocr_dir / "meta.json").write_text(
|
|
'{"zotero_key":"VST001","ocr_status":"done","ocr_model":"PaddleOCR"}',
|
|
encoding="utf-8",
|
|
)
|
|
|
|
_, _, _, _ = postprocess_ocr_result(vault, "VST001", [])
|
|
|
|
meta = json.loads((ocr_dir / "meta.json").read_text(encoding="utf-8"))
|
|
from paperforge.worker.ocr_versions import classify_version_state
|
|
|
|
state = classify_version_state(
|
|
meta=meta,
|
|
expected_raw={"ocr_model": meta["raw_version"]["ocr_model"], "ocr_provider": "PaddleOCR"},
|
|
expected_derived={"renderer_version": "2.0.0"},
|
|
)
|
|
assert "raw_upgradable" in state
|
|
assert "derived_stale" in state
|
|
|
|
|
|
def test_postprocess_writes_role_index(tmp_path: Path) -> None:
|
|
import json
|
|
|
|
from paperforge.worker.ocr import postprocess_ocr_result
|
|
|
|
vault = tmp_path / "vault"
|
|
vault.mkdir()
|
|
(vault / "paperforge.json").write_text(
|
|
json.dumps({"vault_config": {"system_dir": "System", "resources_dir": "Resources"}}),
|
|
encoding="utf-8",
|
|
)
|
|
ocr_root = vault / "System" / "PaperForge" / "ocr"
|
|
ocr_root.mkdir(parents=True)
|
|
ocr_dir = ocr_root / "IDX001"
|
|
ocr_dir.mkdir()
|
|
(ocr_dir / "meta.json").write_text(
|
|
'{"zotero_key":"IDX001","ocr_status":"done","ocr_model":"PaddleOCR"}',
|
|
encoding="utf-8",
|
|
)
|
|
|
|
_, _, _, _ = postprocess_ocr_result(vault, "IDX001", [])
|
|
|
|
assert (ocr_dir / "index" / "role-index.json").exists()
|