From 45de80da5daef8bdc7de7ee0bd6dd46fe5784c84 Mon Sep 17 00:00:00 2001 From: Research Assistant Date: Fri, 24 Apr 2026 16:15:30 +0800 Subject: [PATCH] refactor(phase-9): update all Python imports to paperforge MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Updated 35 files: from paperforge_lite.* → from paperforge.* - Verified: pytest passes (172 passed, 2 skipped) --- .../worker/scripts/literature_pipeline.py | 20 ++++---- scripts/validate_setup.py | 2 +- skills/literature-qa/scripts/ld_deep.py | 4 +- tests/test_cli_paths.py | 8 ++-- tests/test_cli_worker_dispatch.py | 16 +++---- tests/test_config.py | 48 +++++++++---------- tests/test_doctor.py | 2 +- tests/test_ld_deep_config.py | 6 +-- tests/test_legacy_worker_compat.py | 10 ++-- tests/test_ocr_classify.py | 4 +- tests/test_ocr_doctor.py | 34 ++++++------- tests/test_ocr_preflight.py | 2 +- tests/test_ocr_state_machine.py | 2 +- tests/test_pdf_resolver.py | 6 +-- tests/test_repair.py | 2 +- tests/test_smoke.py | 14 +++--- 16 files changed, 90 insertions(+), 90 deletions(-) diff --git a/pipeline/worker/scripts/literature_pipeline.py b/pipeline/worker/scripts/literature_pipeline.py index 43405ad2..f129225a 100644 --- a/pipeline/worker/scripts/literature_pipeline.py +++ b/pipeline/worker/scripts/literature_pipeline.py @@ -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: diff --git a/scripts/validate_setup.py b/scripts/validate_setup.py index 92a7e49f..a988052e 100644 --- a/scripts/validate_setup.py +++ b/scripts/validate_setup.py @@ -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 diff --git a/skills/literature-qa/scripts/ld_deep.py b/skills/literature-qa/scripts/ld_deep.py index 71bc7fc0..7e6106c0 100644 --- a/skills/literature-qa/scripts/ld_deep.py +++ b/skills/literature-qa/scripts/ld_deep.py @@ -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 { diff --git a/tests/test_cli_paths.py b/tests/test_cli_paths.py index 7588b927..19079848 100644 --- a/tests/test_cli_paths.py +++ b/tests/test_cli_paths.py @@ -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 or 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() diff --git a/tests/test_cli_worker_dispatch.py b/tests/test_cli_worker_dispatch.py index 54e83e60..eac37af4 100644 --- a/tests/test_cli_worker_dispatch.py +++ b/tests/test_cli_worker_dispatch.py @@ -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): diff --git a/tests/test_config.py b/tests/test_config.py index fbe8fea7..96b7131e 100644 --- a/tests/test_config.py +++ b/tests/test_config.py @@ -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 diff --git a/tests/test_doctor.py b/tests/test_doctor.py index 47158d5c..f804c7f7 100644 --- a/tests/test_doctor.py +++ b/tests/test_doctor.py @@ -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): diff --git a/tests/test_ld_deep_config.py b/tests/test_ld_deep_config.py index e6a7cf15..ab2646f3 100644 --- a/tests/test_ld_deep_config.py +++ b/tests/test_ld_deep_config.py @@ -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") \ No newline at end of file + assert result["status"] in ("ok", "error") diff --git a/tests/test_legacy_worker_compat.py b/tests/test_legacy_worker_compat.py index 1d76e999..511e1c2f 100644 --- a/tests/test_legacy_worker_compat.py +++ b/tests/test_legacy_worker_compat.py @@ -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}" - ) \ No newline at end of file + ) diff --git a/tests/test_ocr_classify.py b/tests/test_ocr_classify.py index 3623f559..4bcffefe 100644 --- a/tests/test_ocr_classify.py +++ b/tests/test_ocr_classify.py @@ -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: diff --git a/tests/test_ocr_doctor.py b/tests/test_ocr_doctor.py index 1f780203..f28db03f 100644 --- a/tests/test_ocr_doctor.py +++ b/tests/test_ocr_doctor.py @@ -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 diff --git a/tests/test_ocr_preflight.py b/tests/test_ocr_preflight.py index a0ead49d..69a1062b 100644 --- a/tests/test_ocr_preflight.py +++ b/tests/test_ocr_preflight.py @@ -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( diff --git a/tests/test_ocr_state_machine.py b/tests/test_ocr_state_machine.py index 6dd41124..73cb0655 100644 --- a/tests/test_ocr_state_machine.py +++ b/tests/test_ocr_state_machine.py @@ -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}") \ No newline at end of file + pytest.fail(f"run_ocr raised {type(e).__name__}: {e}") diff --git a/tests/test_pdf_resolver.py b/tests/test_pdf_resolver.py index a6a04637..c4ee29f5 100644 --- a/tests/test_pdf_resolver.py +++ b/tests/test_pdf_resolver.py @@ -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()) diff --git a/tests/test_repair.py b/tests/test_repair.py index fa0c1d5b..2a351634 100644 --- a/tests/test_repair.py +++ b/tests/test_repair.py @@ -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 \ No newline at end of file + assert "reason" in item diff --git a/tests/test_smoke.py b/tests/test_smoke.py index 9d96a43c..075b02f8 100644 --- a/tests/test_smoke.py +++ b/tests/test_smoke.py @@ -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),