obsidian-plugin/lllin000_PaperForge
1
0
Fork 0
mirror of https://github.com/lllin000/PaperForge.git synced 2026-07-22 06:50:53 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

refactor(phase-9): update all Python imports to paperforge

Browse source 
- Updated 35 files: from paperforge_lite.* → from paperforge.*
- Verified: pytest passes (172 passed, 2 skipped)
This commit is contained in:
Research Assistant 2026-04-24 16:15:30 +08:00
parent 59457d15c7
commit 45de80da5d
16 changed files with 90 additions and 90 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
pipeline/worker/scripts/literature_pipeline.py
View file

@ -134,19 +134,19 @@ def load_vault_config(vault: Path) -> dict:
"""Read vault configuration — delegates to shared resolver.
Preserves the public name for legacy callers. Configuration precedence:
1. paperforge_lite.config.load_vault_config (overrides > env > JSON > defaults)
1. paperforge.config.load_vault_config (overrides > env > JSON > defaults)
"""
from paperforge_lite.config import load_vault_config as _shared_load_vault_config
from paperforge.config import load_vault_config as _shared_load_vault_config
return _shared_load_vault_config(vault)
def pipeline_paths(vault: Path) -> dict[str, Path]:
"""Build complete PaperForge path inventory — delegates to shared resolver.
Returns paths from paperforge_lite.config.paperforge_paths() plus
Returns paths from paperforge.config.paperforge_paths() plus
worker-only keys. Preserves all legacy keys for existing callers.
"""
from paperforge_lite.config import paperforge_paths as _shared_paperforge_paths
from paperforge.config import paperforge_paths as _shared_paperforge_paths
shared = _shared_paperforge_paths(vault)
@ -951,8 +951,8 @@ def run_selection_sync(vault: Path) -> int:
pdf_attachments = [a for a in item.get('attachments', []) if a.get('contentType') == 'application/pdf']
has_pdf = bool(pdf_attachments)
raw_pdf_path = pdf_attachments[0].get('path', '') if pdf_attachments else ''
from paperforge_lite.pdf_resolver import resolve_pdf_path
from paperforge_lite.config import load_vault_config as _load_vault_config
from paperforge.pdf_resolver import resolve_pdf_path
from paperforge.config import load_vault_config as _load_vault_config
cfg = _load_vault_config(vault)
zotero_dir = vault / cfg.get('system_dir', '99_System') / 'Zotero'
resolved_pdf = resolve_pdf_path(raw_pdf_path, has_pdf, vault, zotero_dir)
@ -2568,7 +2568,7 @@ def postprocess_ocr_result(vault: Path, key: str, all_results: list[dict]) -> tu
return (page_num, markdown_path, json_path, fulltext_md_path)
def run_ocr(vault: Path) -> int:
from paperforge_lite.pdf_resolver import resolve_pdf_path
from paperforge.pdf_resolver import resolve_pdf_path
paths = pipeline_paths(vault)
cleanup_blocked_ocr_dirs(paths)
control_actions = load_control_actions(paths)
@ -2622,7 +2622,7 @@ def run_ocr(vault: Path) -> int:
payload = response.json()['data']
state = payload['state']
except (json.JSONDecodeError, KeyError) as e:
from paperforge_lite.ocr_diagnostics import classify_error
from paperforge.ocr_diagnostics import classify_error
state, suggestion = classify_error(e, None)
meta['ocr_status'] = state
meta['error'] = f'API schema mismatch during polling: {e}'
@ -2702,7 +2702,7 @@ def run_ocr(vault: Path) -> int:
response = requests.post(job_url, headers={'Authorization': f'bearer {token}'}, data={'model': model, 'optionalPayload': json.dumps(optional_payload)}, files={'file': file_handle}, timeout=120)
response.raise_for_status()
except Exception as e:
from paperforge_lite.ocr_diagnostics import classify_error
from paperforge.ocr_diagnostics import classify_error
state, suggestion = classify_error(e, getattr(e, 'response', None))
meta['ocr_status'] = state
meta['error'] = str(e)
@ -3134,7 +3134,7 @@ def run_doctor(vault: Path) -> int:
except Exception as e:
import_error = str(e)
if ld_deep_import_ok:
add_check("Agent 脚本", "pass", "paperforge_lite and ld_deep importable")
add_check("Agent 脚本", "pass", "paperforge and ld_deep importable")
else:
add_check("Agent 脚本", "warn", f"literature-qa skill 目录存在但 import 失败: {import_error}", "确认 agent_config_dir 配置正确并已运行 pip install -e .")
else:

2
scripts/validate_setup.py
View file

@ -23,7 +23,7 @@ def load_config(vault: Path) -> dict:
"""Load vault configuration — prefers shared resolver, falls back to legacy."""
# Try shared resolver first (01-03 and later installs)
try:
from paperforge_lite.config import load_vault_config as _shared_load
from paperforge.config import load_vault_config as _shared_load
return _shared_load(vault)
except ImportError:
pass

4
skills/literature-qa/scripts/ld_deep.py
View file

@ -16,7 +16,7 @@ def _load_vault_config(vault: Path) -> dict:
Preserves the public name for legacy callers.
"""
from paperforge_lite.config import load_vault_config as _shared_load_vault_config
from paperforge.config import load_vault_config as _shared_load_vault_config
return _shared_load_vault_config(vault)
@ -25,7 +25,7 @@ def _paperforge_paths(vault: Path) -> dict[str, Path]:
Returns ocr, records, literature keys matching shared resolver output.
"""
from paperforge_lite.config import paperforge_paths as _shared_paperforge_paths
from paperforge.config import paperforge_paths as _shared_paperforge_paths
shared = _shared_paperforge_paths(vault)
return {

8
tests/test_cli_paths.py
View file

@ -1,4 +1,4 @@
# Tests for paperforge_lite CLI paths command output.
# Tests for paperforge CLI paths command output.
# These tests prove the locked command surface without invoking real workers.
import io
@ -31,7 +31,7 @@ def mock_vault(tmp_path):
# ----------------------------------------------------------------------
def test_paths_json_structure(mock_vault):
"""main(['paths', '--json']) prints valid JSON with D-Path keys."""
from paperforge_lite.cli import main
from paperforge.cli import main
argv = ["--vault", str(mock_vault), "paths", "--json"]
f = io.StringIO()
@ -57,7 +57,7 @@ def test_paths_json_structure(mock_vault):
def test_paths_json_no_unresolved_tokens(mock_vault):
"""paths --json output must not contain <system_dir> or <resources_dir> placeholders."""
from paperforge_lite.cli import main
from paperforge.cli import main
argv = ["--vault", str(mock_vault), "paths", "--json"]
f = io.StringIO()
@ -73,7 +73,7 @@ def test_paths_json_no_unresolved_tokens(mock_vault):
def test_paths_text_no_unresolved_tokens(mock_vault):
"""paths (text mode) output must not contain unresolved path tokens."""
from paperforge_lite.cli import main
from paperforge.cli import main
argv = ["--vault", str(mock_vault), "paths"]
f = io.StringIO()

16
tests/test_cli_worker_dispatch.py
View file

@ -1,4 +1,4 @@
# Tests for paperforge_lite CLI worker dispatch
# Tests for paperforge CLI worker dispatch
# These tests prove the locked command surface without invoking real workers.
import pytest
@ -69,7 +69,7 @@ def mock_vault(tmp_path):
def test_status_dispatch(clean_captured, mock_vault):
"""main(['--vault', vault, 'status']) calls run_status."""
import importlib
import paperforge_lite.cli as cli
import paperforge.cli as cli
importlib.reload(cli)
with patch.object(cli, "run_status", stub_run_status):
@ -82,7 +82,7 @@ def test_status_dispatch(clean_captured, mock_vault):
def test_selection_sync_dispatch(clean_captured, mock_vault):
"""main(['--vault', vault, 'selection-sync']) calls run_selection_sync."""
import importlib
import paperforge_lite.cli as cli
import paperforge.cli as cli
importlib.reload(cli)
with patch.object(cli, "run_selection_sync", stub_run_selection_sync):
@ -95,7 +95,7 @@ def test_selection_sync_dispatch(clean_captured, mock_vault):
def test_index_refresh_dispatch(clean_captured, mock_vault):
"""main(['--vault', vault, 'index-refresh']) calls run_index_refresh."""
import importlib
import paperforge_lite.cli as cli
import paperforge.cli as cli
importlib.reload(cli)
with patch.object(cli, "run_index_refresh", stub_run_index_refresh):
@ -108,7 +108,7 @@ def test_index_refresh_dispatch(clean_captured, mock_vault):
def test_deep_reading_dispatch(clean_captured, mock_vault):
"""main(['--vault', vault, 'deep-reading']) calls run_deep_reading."""
import importlib
import paperforge_lite.cli as cli
import paperforge.cli as cli
importlib.reload(cli)
with patch.object(cli, "run_deep_reading", stub_run_deep_reading):
@ -121,7 +121,7 @@ def test_deep_reading_dispatch(clean_captured, mock_vault):
def test_ocr_run_dispatch(clean_captured, mock_vault):
"""main(['--vault', vault, 'ocr', 'run']) calls run_ocr."""
import importlib
import paperforge_lite.cli as cli
import paperforge.cli as cli
importlib.reload(cli)
with patch.object(cli, "run_ocr", stub_run_ocr):
@ -134,7 +134,7 @@ def test_ocr_run_dispatch(clean_captured, mock_vault):
def test_ocr_alias_dispatch(clean_captured, mock_vault):
"""main(['--vault', vault, 'ocr']) calls run_ocr (alias for 'ocr run')."""
import importlib
import paperforge_lite.cli as cli
import paperforge.cli as cli
importlib.reload(cli)
with patch.object(cli, "run_ocr", stub_run_ocr):
@ -147,7 +147,7 @@ def test_ocr_alias_dispatch(clean_captured, mock_vault):
def test_ocr_doctor_dispatch(clean_captured, mock_vault):
"""main(['--vault', vault, 'ocr', 'doctor']) calls _cmd_ocr_doctor."""
import importlib
import paperforge_lite.cli as cli
import paperforge.cli as cli
importlib.reload(cli)
with patch.object(cli, "_cmd_ocr_doctor", lambda vault, args: 0):

48
tests/test_config.py
View file

@ -1,4 +1,4 @@
"""Tests for paperforge_lite.config resolver contract.
"""Tests for paperforge.config resolver contract.
These tests prove:
- CONF-01: Env vars override JSON values
@ -110,38 +110,38 @@ def env_dict() -> dict[str, str]:
def test_default_system_dir_is_99_System():
"""Built-in default for system_dir must be '99_System'."""
from paperforge_lite.config import DEFAULT_CONFIG
from paperforge.config import DEFAULT_CONFIG
assert DEFAULT_CONFIG["system_dir"] == "99_System"
def test_default_resources_dir_is_03_Resources():
"""Built-in default for resources_dir must be '03_Resources'."""
from paperforge_lite.config import DEFAULT_CONFIG
from paperforge.config import DEFAULT_CONFIG
assert DEFAULT_CONFIG["resources_dir"] == "03_Resources"
def test_default_literature_dir():
from paperforge_lite.config import DEFAULT_CONFIG
from paperforge.config import DEFAULT_CONFIG
assert DEFAULT_CONFIG["literature_dir"] == "Literature"
def test_default_control_dir():
from paperforge_lite.config import DEFAULT_CONFIG
from paperforge.config import DEFAULT_CONFIG
assert DEFAULT_CONFIG["control_dir"] == "LiteratureControl"
def test_default_base_dir():
from paperforge_lite.config import DEFAULT_CONFIG
from paperforge.config import DEFAULT_CONFIG
assert DEFAULT_CONFIG["base_dir"] == "05_Bases"
def test_default_skill_dir():
from paperforge_lite.config import DEFAULT_CONFIG
from paperforge.config import DEFAULT_CONFIG
assert DEFAULT_CONFIG["skill_dir"] == ".opencode/skills"
def test_default_command_dir():
from paperforge_lite.config import DEFAULT_CONFIG
from paperforge.config import DEFAULT_CONFIG
assert DEFAULT_CONFIG["command_dir"] == ".opencode/command"
@ -151,12 +151,12 @@ def test_default_command_dir():
def test_env_keys_has_all_required_overrides():
"""All PAPERFORGE_* env vars must be registered in ENV_KEYS."""
from paperforge_lite.config import ENV_KEYS
from paperforge.config import ENV_KEYS
required = {
"PAPERFORGE_VAULT",
"PAPERFORGE_SYSTEM_DIR",
"PAPERFORGE_RESOURCES_DIR",
"PAPERFORGE_LITERATURE_DIR",
"paperforgeRATURE_DIR",
"PAPERFORGE_CONTROL_DIR",
"PAPERFORGE_BASE_DIR",
"PAPERFORGE_SKILL_DIR",
@ -172,7 +172,7 @@ def test_env_keys_has_all_required_overrides():
def test_env_overrides_nested_json(env_dict):
"""PAPERFORGE_SYSTEM_DIR overrides nested vault_config.system_dir (CONF-01)."""
from paperforge_lite.config import load_vault_config
from paperforge.config import load_vault_config
# Create a vault with nested config
vault = Path("test_vault_env_override")
@ -197,7 +197,7 @@ def test_env_overrides_nested_json(env_dict):
def test_explicit_overrides_win_over_env(env_dict):
"""Explicit overrides passed to load_vault_config win over env vars (CONF-01)."""
from paperforge_lite.config import load_vault_config
from paperforge.config import load_vault_config
vault = Path("test_vault_explicit")
vault.mkdir(exist_ok=True)
@ -217,7 +217,7 @@ def test_explicit_overrides_win_over_env(env_dict):
def test_nested_vault_config_is_honored(tmp_path: Path):
"""Nested vault_config keys are honored when present (CONF-04)."""
from paperforge_lite.config import load_vault_config
from paperforge.config import load_vault_config
vault = tmp_path / "vault_nested"
vault.mkdir()
@ -232,7 +232,7 @@ def test_nested_vault_config_is_honored(tmp_path: Path):
def test_top_level_keys_override_nested_for_backward_compat(tmp_path: Path):
"""Top-level paperforge.json keys override nested vault_config (CONF-04 backward compat)."""
from paperforge_lite.config import load_vault_config
from paperforge.config import load_vault_config
vault = tmp_path / "vault_legacy"
vault.mkdir()
@ -252,7 +252,7 @@ def test_top_level_keys_override_nested_for_backward_compat(tmp_path: Path):
def test_defaults_used_when_no_json(tmp_path: Path):
"""When no paperforge.json exists, defaults are returned."""
from paperforge_lite.config import load_vault_config
from paperforge.config import load_vault_config
vault = tmp_path / "vault_empty"
vault.mkdir()
@ -268,7 +268,7 @@ def test_defaults_used_when_no_json(tmp_path: Path):
def test_paperforge_paths_returns_exact_keys(tmp_path: Path):
"""paperforge_paths() must return exactly the required user-facing keys."""
from paperforge_lite.config import paperforge_paths
from paperforge.config import paperforge_paths
vault = tmp_path / "vault_paths"
vault.mkdir()
@ -310,7 +310,7 @@ def test_paperforge_paths_returns_exact_keys(tmp_path: Path):
def test_paperforge_paths_values_are_absolute(tmp_path: Path):
"""All path values returned must be absolute Path objects."""
from paperforge_lite.config import paperforge_paths
from paperforge.config import paperforge_paths
vault = tmp_path / "vault_absolute"
vault.mkdir()
@ -329,7 +329,7 @@ def test_paperforge_paths_values_are_absolute(tmp_path: Path):
def test_paperforge_paths_includes_worker_script(tmp_path: Path):
"""worker_script key must point to literature_pipeline.py."""
from paperforge_lite.config import paperforge_paths
from paperforge.config import paperforge_paths
vault = tmp_path / "vault_ws"
vault.mkdir()
@ -348,7 +348,7 @@ def test_paperforge_paths_includes_worker_script(tmp_path: Path):
def test_paperforge_paths_includes_ld_deep_script(tmp_path: Path):
"""ld_deep_script key must point to ld_deep.py."""
from paperforge_lite.config import paperforge_paths
from paperforge.config import paperforge_paths
vault = tmp_path / "vault_ld"
vault.mkdir()
@ -371,7 +371,7 @@ def test_paperforge_paths_includes_ld_deep_script(tmp_path: Path):
def test_paths_as_strings_returns_string_values():
"""paths_as_strings must return dict[str, str] with all values as strings."""
from paperforge_lite.config import paths_as_strings
from paperforge.config import paths_as_strings
from pathlib import Path
paths = {
@ -406,7 +406,7 @@ def test_paths_as_strings_returns_string_values():
def test_resolve_vault_precedence_explicit_first(tmp_path: Path):
"""resolve_vault returns explicit cli_vault first."""
from paperforge_lite.config import resolve_vault
from paperforge.config import resolve_vault
vault_a = tmp_path / "vault_a"
vault_b = tmp_path / "vault_b"
@ -419,7 +419,7 @@ def test_resolve_vault_precedence_explicit_first(tmp_path: Path):
def test_resolve_vault_precedence_env_second(tmp_path: Path):
"""resolve_vault returns PAPERFORGE_VAULT when no explicit cli_vault."""
from paperforge_lite.config import resolve_vault
from paperforge.config import resolve_vault
vault = tmp_path / "vault_env"
vault.mkdir()
@ -430,7 +430,7 @@ def test_resolve_vault_precedence_env_second(tmp_path: Path):
def test_resolve_vault_precedence_json_search_third(tmp_path: Path):
"""resolve_vault falls back to scanning cwd for paperforge.json."""
from paperforge_lite.config import resolve_vault
from paperforge.config import resolve_vault
vault = tmp_path / "vault_json"
vault.mkdir()
@ -442,7 +442,7 @@ def test_resolve_vault_precedence_json_search_third(tmp_path: Path):
def test_resolve_vault_precedence_cwd_last(tmp_path: Path):
"""resolve_vault falls back to cwd when no explicit, env, or json."""
from paperforge_lite.config import resolve_vault
from paperforge.config import resolve_vault
result = resolve_vault(cli_vault=None, env={}, cwd=tmp_path)
assert result == tmp_path

2
tests/test_doctor.py
View file

@ -11,7 +11,7 @@ def stub_run_doctor(vault: Path) -> int:
def test_doctor_command_exists(clean_captured, mock_vault):
import importlib
import paperforge_lite.cli as cli
import paperforge.cli as cli
importlib.reload(cli)
with patch("pipeline.worker.scripts.literature_pipeline.run_doctor", stub_run_doctor):

6
tests/test_ld_deep_config.py
View file

@ -58,7 +58,7 @@ class TestDeepLoadVaultConfig:
def test_load_vault_config_keys(self, tmp_vault: Path) -> None:
"""_load_vault_config returns same keys as shared resolver."""
from paperforge_lite.config import load_vault_config as shared_load
from paperforge.config import load_vault_config as shared_load
import ld_deep
shared_cfg = shared_load(tmp_vault)
@ -97,7 +97,7 @@ class TestDeepPaperforgePaths:
self, tmp_vault: Path
) -> None:
"""Values for ocr, records, literature match paperforge_paths()."""
from paperforge_lite.config import paperforge_paths as shared_paths
from paperforge.config import paperforge_paths as shared_paths
import ld_deep
shared = shared_paths(tmp_vault)
@ -130,4 +130,4 @@ class TestDeepPrepareDeepReading:
assert isinstance(result, dict)
assert "status" in result
# Status will be error since key doesn't exist, but function is callable
assert result["status"] in ("ok", "error")
assert result["status"] in ("ok", "error")

10
tests/test_legacy_worker_compat.py
View file

@ -69,11 +69,11 @@ def tmp_vault(tmp_path: Path) -> Path:
class TestWorkerLoadVaultConfig:
"""Test literature_pipeline.load_vault_config matches paperforge_lite.config."""
"""Test literature_pipeline.load_vault_config matches paperforge.config."""
def test_defaults_match_shared_resolver(self, tmp_vault: Path) -> None:
"""load_vault_config returns same top-level keys as shared resolver."""
from paperforge_lite.config import load_vault_config as shared_load
from paperforge.config import load_vault_config as shared_load
import literature_pipeline as lp
shared_cfg = shared_load(tmp_vault)
@ -151,7 +151,7 @@ class TestWorkerPipelinePaths:
self, tmp_vault: Path
) -> None:
"""Verify shared resolver keys have correct values."""
from paperforge_lite.config import paperforge_paths as shared_paths
from paperforge.config import paperforge_paths as shared_paths
import literature_pipeline as lp
shared = shared_paths(tmp_vault)
@ -172,7 +172,7 @@ class TestLegacyStatusSubprocess:
if not worker_script.exists():
pytest.skip("Worker script not found at expected path")
# Run with repo root on PYTHONPATH so paperforge_lite can be imported
# Run with repo root on PYTHONPATH so paperforge can be imported
env = dict(os.environ)
env["PYTHONPATH"] = str(_REPO_ROOT) + (";" if sys.platform == "win32" else ":") + env.get("PYTHONPATH", "")
@ -190,4 +190,4 @@ class TestLegacyStatusSubprocess:
)
assert "ImportError" not in result.stderr, (
f"Import error in stderr: {result.stderr}"
)
)

4
tests/test_ocr_classify.py
View file

@ -1,4 +1,4 @@
"""Tests for paperforge_lite.ocr_diagnostics.classify_error().
"""Tests for paperforge.ocr_diagnostics.classify_error().
Maps exceptions to (state, suggestion) pairs per the D-03 taxonomy.
"""
@ -10,7 +10,7 @@ from unittest.mock import MagicMock
import pytest
import requests
from paperforge_lite.ocr_diagnostics import classify_error
from paperforge.ocr_diagnostics import classify_error
class TestClassifyError:

34
tests/test_ocr_doctor.py
View file

@ -1,4 +1,4 @@
# Tests for paperforge_lite.ocr_diagnostics — tiered L1-L4 checks.
# Tests for paperforge.ocr_diagnostics — tiered L1-L4 checks.
import json
import os
@ -6,7 +6,7 @@ from unittest.mock import patch, MagicMock
import pytest
from paperforge_lite.ocr_diagnostics import ocr_doctor
from paperforge.ocr_diagnostics import ocr_doctor
# ---------------------------------------------------------------------------
@ -33,7 +33,7 @@ def test_l2_bad_url():
mock_resp.status_code = 404
with patch.dict(os.environ, env, clear=True):
with patch("paperforge_lite.ocr_diagnostics.requests.get", return_value=mock_resp):
with patch("paperforge.ocr_diagnostics.requests.get", return_value=mock_resp):
result = ocr_doctor(config=None, live=False)
assert result["level"] == 2
@ -49,7 +49,7 @@ def test_l2_unauthorized():
mock_resp.status_code = 401
with patch.dict(os.environ, env, clear=True):
with patch("paperforge_lite.ocr_diagnostics.requests.get", return_value=mock_resp):
with patch("paperforge.ocr_diagnostics.requests.get", return_value=mock_resp):
result = ocr_doctor(config=None, live=False)
assert result["level"] == 2
@ -72,8 +72,8 @@ def test_l3_schema_mismatch():
post_resp.json.return_value = {"message": "ok"}
with patch.dict(os.environ, env, clear=True):
with patch("paperforge_lite.ocr_diagnostics.requests.get", return_value=get_resp):
with patch("paperforge_lite.ocr_diagnostics.requests.post", return_value=post_resp):
with patch("paperforge.ocr_diagnostics.requests.get", return_value=get_resp):
with patch("paperforge.ocr_diagnostics.requests.post", return_value=post_resp):
result = ocr_doctor(config=None, live=False)
assert result["level"] == 3
@ -95,9 +95,9 @@ def test_l3_success():
delete_resp.status_code = 204
with patch.dict(os.environ, env, clear=True):
with patch("paperforge_lite.ocr_diagnostics.requests.get", return_value=get_resp):
with patch("paperforge_lite.ocr_diagnostics.requests.post", return_value=post_resp):
with patch("paperforge_lite.ocr_diagnostics.requests.delete", return_value=delete_resp):
with patch("paperforge.ocr_diagnostics.requests.get", return_value=get_resp):
with patch("paperforge.ocr_diagnostics.requests.post", return_value=post_resp):
with patch("paperforge.ocr_diagnostics.requests.delete", return_value=delete_resp):
result = ocr_doctor(config=None, live=False)
assert result["level"] == 3
@ -125,12 +125,12 @@ def test_l4_live_success():
with patch.dict(os.environ, env, clear=True):
with patch(
"paperforge_lite.ocr_diagnostics.requests.get",
"paperforge.ocr_diagnostics.requests.get",
side_effect=[get_resp] + [poll_resp] * 10,
):
with patch("paperforge_lite.ocr_diagnostics.requests.post", return_value=post_resp):
with patch("paperforge_lite.ocr_diagnostics.requests.delete", return_value=delete_resp):
with patch("paperforge_lite.ocr_diagnostics.time.sleep"):
with patch("paperforge.ocr_diagnostics.requests.post", return_value=post_resp):
with patch("paperforge.ocr_diagnostics.requests.delete", return_value=delete_resp):
with patch("paperforge.ocr_diagnostics.time.sleep"):
result = ocr_doctor(config=None, live=True)
assert result["level"] == 4
@ -155,12 +155,12 @@ def test_l4_live_failure():
with patch.dict(os.environ, env, clear=True):
with patch(
"paperforge_lite.ocr_diagnostics.requests.get",
"paperforge.ocr_diagnostics.requests.get",
side_effect=[get_resp] + [poll_resp] * 10,
):
with patch("paperforge_lite.ocr_diagnostics.requests.post", return_value=post_resp):
with patch("paperforge_lite.ocr_diagnostics.requests.delete", return_value=delete_resp):
with patch("paperforge_lite.ocr_diagnostics.time.sleep"):
with patch("paperforge.ocr_diagnostics.requests.post", return_value=post_resp):
with patch("paperforge.ocr_diagnostics.requests.delete", return_value=delete_resp):
with patch("paperforge.ocr_diagnostics.time.sleep"):
result = ocr_doctor(config=None, live=True)
assert result["level"] == 4

2
tests/test_ocr_preflight.py
View file

@ -242,7 +242,7 @@ class TestOcrPreflight:
mock_paths["ocr"].mkdir()
with patch(
"paperforge_lite.pdf_resolver.resolve_pdf_path",
"paperforge.pdf_resolver.resolve_pdf_path",
return_value=str(target),
):
with patch(

2
tests/test_ocr_state_machine.py
View file

@ -471,4 +471,4 @@ do_ocr: true
try:
run_ocr(vault)
except Exception as e:
pytest.fail(f"run_ocr raised {type(e).__name__}: {e}")
pytest.fail(f"run_ocr raised {type(e).__name__}: {e}")

6
tests/test_pdf_resolver.py
View file

@ -1,4 +1,4 @@
"""Tests for paperforge_lite.pdf_resolver.
"""Tests for paperforge.pdf_resolver.
Covers absolute, vault-relative, junction, storage-relative, missing file,
and has_pdf=False scenarios.
@ -13,7 +13,7 @@ from unittest.mock import patch
import pytest
from paperforge_lite.pdf_resolver import is_valid_pdf, resolve_junction, resolve_pdf_path
from paperforge.pdf_resolver import is_valid_pdf, resolve_junction, resolve_pdf_path
class TestResolvePdfPath:
@ -48,7 +48,7 @@ class TestResolvePdfPath:
return path
monkeypatch.setattr(
"paperforge_lite.pdf_resolver.resolve_junction", mock_resolve_junction
"paperforge.pdf_resolver.resolve_junction", mock_resolve_junction
)
result = resolve_pdf_path(str(junction), True, tmp_path)
assert result == str(target.resolve())

2
tests/test_repair.py
View file

@ -364,4 +364,4 @@ class TestRunRepairReturnStructure:
assert "library_record_ocr_status" in item
assert "formal_note_ocr_status" in item
assert "meta_ocr_status" in item
assert "reason" in item
assert "reason" in item

14
tests/test_smoke.py
View file

@ -120,12 +120,12 @@ class TestLdDeepImport:
def test_regression_agent_importability(self, test_vault: Path) -> None:
"""REG-02: ld_deep.py runs without manual PYTHONPATH."""
result = subprocess.run(
[sys.executable, "-c", "import paperforge_lite"],
[sys.executable, "-c", "import paperforge"],
capture_output=True,
text=True,
cwd=str(REPO_ROOT),
)
assert result.returncode == 0, f"paperforge_lite should be importable: {result.stderr}"
assert result.returncode == 0, f"paperforge should be importable: {result.stderr}"
class TestPrepareProducesScaffold:
@ -202,7 +202,7 @@ class TestWorkerPathsJson:
def test_regression_worker_path_json(self, test_vault: Path) -> None:
"""Verify paths --json returns worker_script and ld_deep_script."""
from paperforge_lite.config import paperforge_paths
from paperforge.config import paperforge_paths
paths = paperforge_paths(test_vault)
assert "worker_script" in paths, "paths should contain worker_script"
@ -229,7 +229,7 @@ class TestDocCommandsExecutable:
for block in code_blocks:
for line in block.splitlines():
line = line.strip()
if line.startswith("paperforge ") or line.startswith("python -m paperforge_lite"):
if line.startswith("paperforge ") or line.startswith("python -m paperforge"):
commands_found.append((doc_path.name, line))
assert len(commands_found) > 0, "should find commands in docs"
@ -247,7 +247,7 @@ class TestDocCommandsExecutable:
if parts[0] == "paperforge":
try:
result = subprocess.run(
[sys.executable, "-m", "paperforge_lite", *parts[1:], "--help"],
[sys.executable, "-m", "paperforge", *parts[1:], "--help"],
capture_output=True,
text=True,
cwd=str(REPO_ROOT),
@ -257,10 +257,10 @@ class TestDocCommandsExecutable:
pass
except Exception as e:
failures.append(f"{doc_name}: {cmd} -> {e}")
elif "python" in parts[0] and "-m" in parts and "paperforge_lite" in cmd:
elif "python" in parts[0] and "-m" in parts and "paperforge" in cmd:
try:
result = subprocess.run(
[sys.executable, "-m", "paperforge_lite", "--help"],
[sys.executable, "-m", "paperforge", "--help"],
capture_output=True,
text=True,
cwd=str(REPO_ROOT),