Simplify Space layout and use CPU-only ONNX runtime

.gitattributes

@@ -48,6 +48,4 @@ examples/epub_01.epub filter=lfs diff=lfs merge=lfs -text
 examples/epub_02.epub filter=lfs diff=lfs merge=lfs -text
 examples/pptx_01.odp filter=lfs diff=lfs merge=lfs -text
 examples/xlsx_01.ods filter=lfs diff=lfs merge=lfs -text
-docx_01.doc filter=lfs diff=lfs merge=lfs -text
-docx_01.docx filter=lfs diff=lfs merge=lfs -text
 examples/docx_01.odt filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -4,3 +4,5 @@ __pycache__/
 output/
 tmp/
 .ruff_cache/
+.DS_Store
+.zcode/

README.md

@@ -23,35 +23,26 @@ Paper: https://huggingface.co/papers/2409.18839
 
 ## ZeroGPU runtime
 
-Flash TXT runs only in the CPU/PDFium sidecar. Flash OCR and every Basic PDF request
-use `spaces.GPU(duration=60)`. Native Office/HTML/OFD inputs remain Flash CPU.
-The maximum is Basic and the page limit is 20.
-
-`app.py` checks MinerU's dev HEAD once per startup, builds an isolated environment
-at that exact commit, verifies dependencies and integration hooks, and switches
-only after success. A failed update keeps the previously verified environment.
-No usable cached environment means startup fails clearly. The cache defaults to
-`~/.cache/mineru-space-runtime` and can be relocated with `MINERU_RUNTIME_CACHE`;
-it follows the Space's storage lifetime. The cache lives outside the Git checkout
-so devmode's `git clean` cannot remove the working environment. Keep `current.json`
-and `previous.json` for rollback. The launcher explicitly asks uv for Python 3.12:
-HF devmode may retain a Python 3.10 system launcher despite README metadata.
-
-Torch models load at startup through ZeroGPU's CUDA emulation. PDFium and ONNX
-sessions are never preloaded in that parent process. GPU-worker rendering is
-serial and governed by a **60-second GPU parse watchdog**, not a separate
-`MINERU_PDF_RENDER_TIMEOUT` or render-thread setting. The platform's `duration`
-may only warn when exceeded, so the watchdog terminates only the dedicated GPU
-worker if parsing overruns. Scheduling, worker preparation and result transfer
-are measured separately; cancellation does not pretend to interrupt native code.
-
-Defaults: `MINERU_INTRA_OP_NUM_THREADS=4`, `MINERU_INTER_OP_NUM_THREADS=1`,
-`MINERU_TABLE_DEVICE=cpu`. Set the latter to `cuda` to test table CUDA inference;
-sessions are created only inside the GPU worker and report their actual provider.
-`MINERU_PROFILE_STAGES=1` enables wall-clock stage logs (no extra CUDA synchronization).
-The `dispatch_to_entry_s` metric includes scheduling and worker preparation; it
-is not a pure GPU queue-time measurement. GPU return and parent completion
-timestamps expose result-transfer overhead.
-
-Cancellation stops delivering the old result and waits for the underlying GPU
-call before releasing its slot. It does not claim to interrupt native inference.
+`app.py` launches the code in `mineru_space/`. Flash TXT and native Office/HTML/OFD
+inputs run in a CPU/PDFium sidecar; Flash OCR and all Basic PDF requests use
+ZeroGPU. The maximum is Basic, with 20 pages and a 60-second GPU parse watchdog.
+Cancellation waits for native work to finish before releasing the request slot.
+
+The Space image supplies Python 3.12. The launcher reuses that interpreter to
+create an isolated environment, installs MinerU's exact dev HEAD, verifies it,
+and activates it only after success. Failed updates keep an existing compatible
+runtime; no usable runtime means startup fails clearly. The cache defaults to
+`~/.cache/mineru-space-runtime` (`MINERU_RUNTIME_CACHE` overrides it), outside
+the checkout, and follows the Space's storage lifetime. Current and previous
+runtime manifests are retained for rollback.
+
+The root `requirements.txt` installs launcher dependencies. The application
+pins are in `mineru_space/runtime-requirements.txt`. Only CPU `onnxruntime` is
+installed; table inference is fixed to CPU with default intra/inter-op threads
+of 4/1 (`MINERU_INTRA_OP_NUM_THREADS` / `MINERU_INTER_OP_NUM_THREADS`). Torch
+models still use CUDA and preload through ZeroGPU's emulation at startup.
+PDFium and ONNX sessions are not initialized in that parent process.
+
+`MINERU_PROFILE_STAGES=1` enables stage timings. Dispatch-to-entry time includes
+GPU scheduling and worker preparation. GPU-worker PDF rendering is serial;
+its deadline is the whole-request watchdog, not a separate render timeout.

VALIDATION.md

@@ -1,74 +0,0 @@
-# ZeroGPU 验证记录（2026-09-20）
-
-性能对照的 MinerU 核心提交：`9168ac7b178035d77c7be2338b09fe6d281c81fb`。
-在 opendatalab/MinerU devmode 的独立进程、隔离 Python 环境和测试端口执行；性能测试期间正式服务保持原版本。
-
-## 环境与性能
-
-实际 GPU：NVIDIA RTX PRO 6000 Blackwell Server Edition MIG 2g.48gb。
-容器 CPU quota 为 16 核，进程可见 192 个逻辑核。Torch 2.13.0 CUDA 13，spaces 0.51.3。
-基线为 Python 3.10.13 / CPU ORT 1.23.2；候选为 Python 3.12.14 / ORT GPU 1.29.0 / DocVortex 0.4.15。
-CPU 和 CUDA 候选使用同一套新环境。下表包含调度、worker 准备、解析和结果 IPC，不包含启动期预加载与输出持久化。
-
-`demo1.pdf`，13 页，Basic + Auto（实际 TXT）：
-
-| 配置 | 第一次 GPU 调用 | 第二次 | 第三次 |
-| --- | ---: | ---: | ---: |
-| 原始版本 | 38.453 s | 36.108 s | 35.264 s |
-| 原环境，仅限制 ONNX 为 4 线程 | 23.078 s | 9.390 s | 9.559 s |
-| 新运行时 + 4 线程 + Torch 预加载 | 13.930 s | 7.984 s | 7.842 s |
-| 同一候选，表格 CUDA | 20.382 s | 8.046 s | 7.595 s |
-
-基线三个请求使用不同 worker；其他组本次均复用了各自的 worker。不能保证未来请求一定复用。
-CUDA 第一次调用有 9.346 s 的调度/worker 准备时间，不能将这部分归因于模型推理。
-去掉该部分后首次解析分别为 CPU 12.788 s、CUDA 10.859 s，仍存在不同阶段冷缓存的影响。
-
-更直接的表格阶段对照：首次 CPU 1.120 s、CUDA 1.383 s；后两次 CPU 0.460/0.507 s、CUDA 0.486/0.453 s。
-未观察到稳定的整份文档收益达到既定启用门槛，所以 Space 默认 `MINERU_TABLE_DEVICE=cpu`，保留 CUDA 开关。
-新配置的正文回填约 3.2–3.5 s，是后续进一步分析的主要 CPU 阶段之一。
-
-## CUDA 确认与质量
-
-完整请求的 ONNX profiling 已确认三个表格模型真实执行 CUDA 节点：
-
-| 模型 | CUDA 节点执行数 | CPU 节点执行数 |
-| --- | ---: | ---: |
-| 表格分类 | 102 | 2 |
-| SLANet | 21209 | 1822 |
-| UNet | 198 | 30 |
-
-CPU 节点为图中保留的 CPU 运算；不是整个会话静默回退。
-四组全部 12 次解析的 ModelJson pages、MiddleJson pages、布局元数据和 Markdown 与基线完全相同。
-三组首次结果生成 PDF 后，13 页逐页以 900 px 栅格化，CPU 候选和 CUDA 候选均与基线像素完全一致。
-人工检查了第五页旋转表格及布局标框，方向和归属保持一致。
-已有基线限制：第五页竖向表格说明在重建 PDF 中仍有窄列换行，本次未改变其排版。
-
-## 路由、界面与故障
-
-- 28 个 Space 测试在 macOS 和 Linux Python 3.12 均通过；补充启动器显式选择 Python 3.12 的测试后，macOS 共 29 个通过。覆盖完整分流矩阵、混合 PDF 选页分类、20 页约束、取消及更新事务。
-- 173 个相关 MinerU 测试通过，包含 ONNX 模型栈、表格自动选择及回退、Flash 调度、模型预加载、内存生命周期、公式/表格路由及异步运行时。其中自动选择变更后重跑受影响组 66 个通过，其余 107 个已在前一提交验证。
-- 新增代码 Ruff 通过；旧表格模块原有的 91 个类型注解告警数量和规则均未增加。
-- 浏览器实际完成 Flash TXT，日志 `use_gpu=false`，没有 GPU 入口事件；经过 bootstrap 启动的 Basic 默认路径也完成，界面显示约 14.9 s。
-- `caibao1.pdf` 前 20 页 Basic 完成，GPU 调用约 16.23 s；页号保持 0–19。Flash OCR 和 Basic OCR 扫描件分别完成。
-- 真实候选环境安装并校验精确 dev SHA；同 SHA 再启动跳过安装；注入网络失败和安装失败均返回同一个可用旧环境。
-- 平台 `duration=1` 的测试仍运行约 10.6 s 才返回，说明不能将该参数当成严格的应用超时。
-- 新增看门狗在真实 GPU worker 中用 0.2 s 测试预算触发退出，主进程继续存活，后续请求成功重建 worker。
-- 另行注入 worker 异常退出，平台返回 `GPU task aborted` 后下一次调用成功。
-
-## 表格自动选择补充
-
-按后续确认的范围，核心提交 `bf8a518d235eef420275e446ecfc59a598a0260a` 将表格默认设备改为 `auto`，仅覆盖表格分类、SLANet 和 UNet。安装兼容 GPU ORT 后优先选择可用 CUDA provider，失败记录原因并回退 CPU；Layout、OCR、公式的 ONNX 后端保持 CPU。
-
-独立 ZeroGPU 请求未设置 `MINERU_TABLE_DEVICE`，三个实际模型均返回 `CUDAExecutionProvider`，并完成真实分类推理；正式 Space 仍显式设置 `cpu`。Space 重启已自动安装该精确 dev SHA，通过依赖校验并完成 Torch 预加载。Devmode 保持开启，SSH 可用。
-
-## 复现
-
-```bash
-python -m pytest -q tests
-python benchmark_space.py --variant preload --pdf examples/demo1.pdf --repeats 3 --output output/bench-cpu
-python benchmark_space.py --variant cuda --pdf examples/demo1.pdf --repeats 3 --output output/bench-cuda
-python benchmark_space.py --variant cuda --pdf examples/demo1.pdf --repeats 1 --profile --output output/bench-profile
-```
-
-每个性能组使用独立父进程，并串行运行。profiling 单独执行，不把其额外开销算进性能对照。
-完整本地日志和样例产物保存在工作区 `output/validation/`，未提交大体积生成文件。

app.py

@@ -1,6 +1,6 @@
 """Space 启动入口；spawn 导入本模块时不会更新依赖或初始化模型。"""
 
 if __name__ == "__main__":
-    from bootstrap import main
+    from mineru_space.bootstrap import main
 
     main()

benchmark_space.py

@@ -1,137 +0,0 @@
-"""在独立进程中对照 ZeroGPU 冷启动、连续请求和表格 provider，不修改正式服务。"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import time
-from pathlib import Path
-
-
-def parse_and_profile(
-    path: str,
-    *,
-    tier: str,
-    ocr_mode: str,
-    page_range: str,
-    request_id: str,
-    submitted_at: float,
-):
-    """在 GPU 租约内解析并收集已创建 ONNX 会话的执行轨迹。"""
-    import torch
-    from space_runtime import gpu_task_entry, log_event
-
-    log_event("benchmark.device", device=torch.cuda.get_device_name())
-    result = gpu_task_entry(
-        path,
-        tier=tier,
-        ocr_mode=ocr_mode,
-        page_range=page_range,
-        request_id=request_id,
-        submitted_at=submitted_at,
-    )
-    if os.getenv("MINERU_ONNX_PROFILE_DIR"):
-        from mineru.model.runtime.hybrid import AtomModelSingleton
-
-        for model in AtomModelSingleton._models.values():
-            # 三类表格包装器拥有不同属性，按确定的对象结构取出真实 ORT session。
-            if hasattr(model, "sess"):
-                session = model.sess
-            elif hasattr(model, "table_model"):
-                session = model.table_model.table_structure.session.session
-            elif hasattr(model, "wired_table_model"):
-                session = model.wired_table_model.table_structure.session.session
-            else:
-                continue
-            if hasattr(session, "end_profiling"):
-                log_event(
-                    "benchmark.onnx_profile",
-                    path=session.end_profiling(),
-                    providers=session.get_providers(),
-                )
-    return result
-
-
-def main() -> None:
-    """每个对照组使用新父进程；PDF 持久化始终放在 sidecar 中避免污染后续 fork。"""
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--variant", choices=["baseline", "threads", "preload", "cuda"], required=True
-    )
-    parser.add_argument("--pdf", default="/app/examples/demo1.pdf")
-    parser.add_argument("--tier", default="basic")
-    parser.add_argument("--ocr-mode", default="auto")
-    parser.add_argument("--page-range", default="")
-    parser.add_argument("--repeats", type=int, default=3)
-    parser.add_argument("--output", required=True)
-    parser.add_argument("--profile", action="store_true")
-    args = parser.parse_args()
-    from space_runtime import configure_environment, preload_torch_models
-
-    configure_environment()
-    os.environ["MINERU_TABLE_DEVICE"] = "cuda" if args.variant == "cuda" else "cpu"
-    if args.variant == "baseline":
-        os.environ.pop("MINERU_INTRA_OP_NUM_THREADS", None)
-        os.environ.pop("MINERU_INTER_OP_NUM_THREADS", None)
-    output = Path(args.output).resolve()
-    output.mkdir(parents=True, exist_ok=True)
-    if args.profile:
-        os.environ["MINERU_ONNX_PROFILE_DIR"] = str(output / "onnx")
-    import spaces
-    import pdf_sidecar
-    from space_app import sidecar_call, shutdown_sidecar
-
-    try:
-        sidecar_call(pdf_sidecar.read_page_metadata, None)
-        if args.variant in {"preload", "cuda"}:
-            preload_torch_models()
-        task = spaces.GPU(duration=60)(parse_and_profile)
-        records = []
-        for index in range(args.repeats):
-            started = time.monotonic()
-            result = task(
-                args.pdf,
-                tier=args.tier,
-                ocr_mode=args.ocr_mode,
-                page_range=args.page_range,
-                request_id=f"{args.variant}-{index}",
-                submitted_at=started,
-            )
-            elapsed = time.monotonic() - started
-            persist_started = time.monotonic()
-            artifacts = sidecar_call(
-                pdf_sidecar.persist,
-                result,
-                args.pdf,
-                output_root=str(output / str(index)),
-                page_range=args.page_range,
-            )
-            record = {
-                "run": index,
-                "gpu_call_s": elapsed,
-                "persist_s": time.monotonic() - persist_started,
-                "artifacts": artifacts.as_state(),
-            }
-            records.append(record)
-            (output / "report.json").write_text(
-                json.dumps({"variant": args.variant, "records": records}, indent=2),
-                encoding="utf-8",
-            )
-            print(
-                json.dumps(
-                    {
-                        "benchmark": args.variant,
-                        "run": index,
-                        "gpu_call_s": elapsed,
-                        "persist_s": record["persist_s"],
-                    }
-                ),
-                flush=True,
-            )
-    finally:
-        shutdown_sidecar()
-
-
-if __name__ == "__main__":
-    main()

mineru_space/__init__.py

@@ -0,0 +1,3 @@
+"""Space 运行模块；导入时不初始化模型或更新环境。"""
+
+__all__ = []

bootstrap.py → mineru_space/bootstrap.py

@@ -14,8 +14,6 @@ import uuid
 from pathlib import Path
 
 DEV_REPOSITORY = "https://github.com/myhloli/Magic-PDF.git"
-ORT_VERSION = "1.29.0"
-PYTHON_VERSION = "3.12"
 
 
 def run(command: list[str], *, timeout: int = 900, capture: bool = False) -> str:
@@ -53,7 +51,11 @@ def write_json(path: Path, value: dict) -> None:
 def validate(root: Path, environment: Path, commit: str) -> None:
     """在独立进程校验包来源、依赖、CPU/GPU 包冲突及所需适配接口。"""
     run(
-        [str(environment / "bin/python"), str(root / "runtime_preflight.py"), commit],
+        [
+            str(environment / "bin/python"),
+            str(root / "mineru_space" / "runtime_preflight.py"),
+            commit,
+        ],
         timeout=90,
     )
 
@@ -76,8 +78,8 @@ def active_environment(cache: Path) -> tuple[Path, dict] | None:
 def build_candidate(
     root: Path, cache: Path, commit: str, fingerprint: str
 ) -> tuple[Path, dict]:
-    """依赖装入全新 venv，最后只保留 GPU 版 ORT，所有变更均不触碰旧环境。"""
-    name = f"py{PYTHON_VERSION.replace('.', '')}-{commit[:12]}-{uuid.uuid4().hex[:8]}"
+    """沿用宿主解释器，在新 venv 中一次安装依赖，不触碰旧环境。"""
+    name = f"py{sys.version_info.major}{sys.version_info.minor}-{commit[:12]}-{uuid.uuid4().hex[:8]}"
     environment = cache / name
     python = environment / "bin/python"
     try:
@@ -88,7 +90,7 @@ def build_candidate(
                 "uv",
                 "venv",
                 "--python",
-                PYTHON_VERSION,
+                sys.executable,
                 str(environment),
             ],
             timeout=120,
@@ -103,37 +105,10 @@ def build_candidate(
                 "--python",
                 str(python),
                 "-r",
-                str(root / "runtime-requirements.txt"),
+                str(root / "mineru_space" / "runtime-requirements.txt"),
                 f"mineru[torch] @ git+{DEV_REPOSITORY}@{commit}",
             ]
         )
-        # MinerU 的基础依赖会安装 CPU 包；先统一移除，随后重装 GPU 包避免共享文件残留。
-        run(
-            [
-                sys.executable,
-                "-m",
-                "uv",
-                "pip",
-                "uninstall",
-                "--python",
-                str(python),
-                "onnxruntime",
-                "onnxruntime-gpu",
-            ]
-        )
-        run(
-            [
-                sys.executable,
-                "-m",
-                "uv",
-                "pip",
-                "install",
-                "--python",
-                str(python),
-                "--no-deps",
-                f"onnxruntime-gpu=={ORT_VERSION}",
-            ]
-        )
         validate(root, environment, commit)
         state = {"environment": name, "commit": commit, "fingerprint": fingerprint}
         write_json(environment / "ready.json", state)
@@ -165,9 +140,9 @@ def select_environment(root: Path, cache: Path) -> Path:
         fcntl.flock(lock, fcntl.LOCK_EX)
         previous = active_environment(cache)
         fingerprint = hashlib.sha256(
-            (root / "runtime-requirements.txt").read_bytes()
-            + (root / "runtime_preflight.py").read_bytes()
-            + f"{PYTHON_VERSION}:{ORT_VERSION}".encode()
+            (root / "mineru_space" / "runtime-requirements.txt").read_bytes()
+            + (root / "mineru_space" / "runtime_preflight.py").read_bytes()
+            + sys.version.encode()
         ).hexdigest()
         try:
             commit = dev_head()
@@ -203,7 +178,8 @@ def select_environment(root: Path, cache: Path) -> Path:
 
 def main() -> None:
     """只由 app.py 主入口更新环境，再以 exec 替换为真实应用进程。"""
-    root = Path(__file__).resolve().parent
+    root = Path(__file__).resolve().parents[1]
+    os.chdir(root)
     cache = Path(
         os.getenv(
             "MINERU_RUNTIME_CACHE", str(Path.home() / ".cache/mineru-space-runtime")
@@ -214,5 +190,5 @@ def main() -> None:
     os.environ["PATH"] = f"{environment / 'bin'}:{os.environ.get('PATH', '')}"
     os.execv(
         str(environment / "bin/python"),
-        [str(environment / "bin/python"), str(root / "space_app.py")],
+        [str(environment / "bin/python"), "-m", "mineru_space.space_app"],
     )

runtime-requirements.txt → mineru_space/runtime-requirements.txt

@@ -6,4 +6,4 @@ docvortex==0.4.15
 numpy==2.2.6
 pydantic==2.12.5
 transformers==5.17.0
-onnxruntime-gpu==1.29.0
+onnxruntime==1.29.0

runtime_preflight.py → mineru_space/runtime_preflight.py

@@ -9,19 +9,15 @@ import sys
 
 
 def main(commit: str) -> None:
-    """校验安装来源和应用依赖，显式认可 GPU 发行包提供 onnxruntime 导入模块。"""
+    """校验提交来源、常规依赖和 CPU ORT，确保候选满足应用运行条件。"""
     from packaging.requirements import Requirement
     from packaging.utils import canonicalize_name
 
-    if sys.version_info[:2] != (3, 12):
-        raise RuntimeError("The application runtime must use Python 3.12")
-
     installed = {
         canonicalize_name(d.metadata["Name"]): d for d in metadata.distributions()
     }
-    if "onnxruntime" in installed:
-        raise RuntimeError("CPU and GPU ONNX Runtime distributions must not coexist")
-    assert metadata.version("onnxruntime-gpu") == "1.29.0"
+    if "onnxruntime-gpu" in installed or "onnxruntime" not in installed:
+        raise RuntimeError("The Space requires CPU onnxruntime without onnxruntime-gpu")
     info = json.loads(
         metadata.distribution("mineru").read_text("direct_url.json") or "{}"
     )
@@ -40,8 +36,6 @@ def main(commit: str) -> None:
             ):
                 continue
             name = canonicalize_name(requirement.name)
-            if name == "onnxruntime":
-                name = "onnxruntime-gpu"
             found = installed.get(name)
             if found is None or (
                 requirement.specifier and found.version not in requirement.specifier
@@ -58,8 +52,8 @@ def main(commit: str) -> None:
     from mineru.parser import parse
 
     assert spaces is not None and callable(table_ort_session)
-    assert torch.version.cuda and torch.version.cuda.startswith("13.")
-    assert "CUDAExecutionProvider" in ort.get_available_providers()
+    assert torch.version.cuda, "ZeroGPU requires a CUDA build of Torch"
+    assert "CPUExecutionProvider" in ort.get_available_providers()
     assert callable(images._load_images_from_pdf_worker)
     assert "max_pages" in inspect.signature(build_gradio_app).parameters
     assert {"tier", "ocr_mode", "page_range"} <= set(
@@ -79,7 +73,7 @@ def main(commit: str) -> None:
                         "spaces",
                         "gradio",
                         "docvortex",
-                        "onnxruntime-gpu",
+                        "onnxruntime",
                     ]
                 },
                 "cuda": torch.version.cuda,

space_app.py → mineru_space/space_app.py

@@ -13,8 +13,8 @@ from concurrent.futures import ProcessPoolExecutor
 from pathlib import Path
 from typing import Any, Callable
 
-import pdf_sidecar
-from space_runtime import (
+from . import pdf_sidecar
+from .space_runtime import (
     configure_environment,
     gpu_task_entry,
     log_event,

space_runtime.py → mineru_space/space_runtime.py

@@ -42,18 +42,16 @@ def timed(event: str, **fields: Any) -> Iterator[None]:
 def configure_environment() -> None:
     """主进程在导入 spaces/Torch/MinerU 前建立统一运行配置。"""
     os.environ["MINERU_DEVICE_MODE"] = "cuda"
+    os.environ["MINERU_TABLE_DEVICE"] = "cpu"
     os.environ["GRADIO_SSR_MODE"] = "False"
     for name, value in {
         "MINERU_MODEL_SOURCE": "huggingface",
         "MINERU_INTRA_OP_NUM_THREADS": "4",
         "MINERU_INTER_OP_NUM_THREADS": "1",
-        "MINERU_TABLE_DEVICE": "cpu",
         "MINERU_PROFILE_STAGES": "1",
         "MINERU_ZEROGPU_DURATION": "60",
     }.items():
         os.environ.setdefault(name, value)
-    if os.environ["MINERU_TABLE_DEVICE"] not in {"cpu", "cuda"}:
-        raise ValueError("MINERU_TABLE_DEVICE must be cpu or cuda")
 
 
 def preload_torch_models() -> None:

tests/test_bootstrap.py

@@ -1,112 +0,0 @@
-"""用隔离缓存验证更新事务，失败不会删除或替换上次可用环境。"""
-
-import json
-import pytest
-
-import bootstrap
-
-
-def prepare(tmp_path):
-    """构造可运行缓存记录与最小配置，不安装实际依赖。"""
-    root, cache = tmp_path / "app", tmp_path / "cache"
-    root.mkdir()
-    cache.mkdir()
-    (root / "runtime-requirements.txt").write_text("test\n")
-    (root / "runtime_preflight.py").write_text("test\n")
-    environment = cache / "old"
-    (environment / "bin").mkdir(parents=True)
-    (environment / "bin/python").touch()
-    state = {"environment": "old", "commit": "a" * 40, "fingerprint": "old"}
-    bootstrap.write_json(environment / "ready.json", state)
-    bootstrap.write_json(cache / "current.json", state)
-    return root, cache, environment, state
-
-
-@pytest.mark.parametrize("failure", ["network", "installation"])
-def test_failure_keeps_last_working_environment(monkeypatch, tmp_path, failure):
-    """网络或安装失败均保留当前清单，并在回退前验证旧环境。"""
-    root, cache, environment, state = prepare(tmp_path)
-    validations = []
-
-    def fail(*args, **kwargs):
-        """模拟候选更新失败。"""
-        raise RuntimeError("offline")
-
-    monkeypatch.setattr(
-        bootstrap, "dev_head", fail if failure == "network" else lambda: "b" * 40
-    )
-    monkeypatch.setattr(bootstrap, "build_candidate", fail)
-    monkeypatch.setattr(bootstrap, "validate", lambda *args: validations.append(args))
-    assert bootstrap.select_environment(root, cache) == environment
-    assert json.loads((cache / "current.json").read_text()) == state
-    assert validations == [(root, environment, "a" * 40)]
-
-
-def test_no_cache_fails_clearly(monkeypatch, tmp_path):
-    """没有可用缓存时不能假装更新成功。"""
-    root, cache, _, _ = prepare(tmp_path)
-    (cache / "current.json").unlink()
-    monkeypatch.setattr(bootstrap, "dev_head", lambda: "b" * 40)
-
-    def fail(*args):
-        """模拟首次安装失败。"""
-        raise RuntimeError("install failed")
-
-    monkeypatch.setattr(bootstrap, "build_candidate", fail)
-    with pytest.raises(RuntimeError, match="No verified"):
-        bootstrap.select_environment(root, cache)
-
-
-def test_activation_preserves_previous(monkeypatch, tmp_path):
-    """只有候选构建成功后才替换 current，并保存上一份完整清单。"""
-    root, cache, old, state = prepare(tmp_path)
-    new = cache / "new"
-    new_state = {"environment": "new", "commit": "b" * 40, "fingerprint": "new"}
-    monkeypatch.setattr(bootstrap, "dev_head", lambda: "b" * 40)
-    monkeypatch.setattr(bootstrap, "build_candidate", lambda *a: (new, new_state))
-    assert bootstrap.select_environment(root, cache) == new
-    assert json.loads((cache / "previous.json").read_text()) == state
-    assert json.loads((cache / "current.json").read_text()) == new_state
-    assert (old / "bin/python").is_file()
-
-
-def test_rejects_environment_outside_cache(tmp_path):
-    """损坏清单不能指向缓存以外的 Python 环境。"""
-    _, cache, _, _ = prepare(tmp_path)
-    bootstrap.write_json(cache / "current.json", {"environment": "../outside"})
-    assert bootstrap.active_environment(cache) is None
-
-
-def test_cleanup_only_removes_owned_retired_environments(tmp_path):
-    """清理仅作用于带成功标记的历史环境，保留当前版本和其他文件。"""
-    current = tmp_path / ("py312-" + "a" * 12 + "-" + "1" * 8)
-    retired = tmp_path / ("py312-" + "b" * 12 + "-" + "2" * 8)
-    unrelated = tmp_path / "notes"
-    for directory in (current, retired, unrelated):
-        directory.mkdir()
-        bootstrap.write_json(directory / "ready.json", {"environment": directory.name})
-    bootstrap.prune_environments(tmp_path, {current.name})
-    assert current.is_dir() and unrelated.is_dir() and not retired.exists()
-
-
-def test_candidate_python_does_not_follow_launcher(monkeypatch, tmp_path):
-    """HF devmode 的系统 Python 可能固定为 3.10，候选环境必须显式选择 3.12。"""
-    commands = []
-
-    def fake_run(command, **kwargs):
-        """模拟环境创建，仅保存命令和 Python 路径用于验证安装边界。"""
-        commands.append(command)
-        if "venv" in command:
-            environment = tmp_path / command[-1]
-            (environment / "bin").mkdir(parents=True)
-            (environment / "bin/python").touch()
-        return ""
-
-    monkeypatch.setattr(bootstrap, "run", fake_run)
-    monkeypatch.setattr(bootstrap, "validate", lambda *args: None)
-    environment, _ = bootstrap.build_candidate(tmp_path, tmp_path, "a" * 40, "test")
-    assert commands[0][commands[0].index("--python") + 1] == "3.12"
-    assert environment.name.startswith("py312-")
-    assert any(
-        f"@{'a' * 40}" in argument for command in commands for argument in command
-    )

tests/test_space.py

@@ -1,244 +0,0 @@
-"""验证 GPU 分流、spawn 无副作用与取消后的真实任务串行边界。"""
-
-import asyncio
-import subprocess
-import sys
-import threading
-import time
-import multiprocessing
-from contextvars import ContextVar
-from pathlib import Path
-
-import pytest
-
-import pdf_sidecar
-import space_app
-from space_runtime import gpu_deadline
-
-
-def slow_gpu_worker():
-    """模拟卡住的独立推理进程，验证看门狗不会结束测试主进程。"""
-    with gpu_deadline(0.1, "test-timeout"):
-        time.sleep(5)
-
-
-def test_watchdog_terminates_only_daemon_worker():
-    """超时 worker 以明确状态退出，父进程仍能继续处理其他任务。"""
-    process = multiprocessing.get_context("spawn").Process(
-        target=slow_gpu_worker, daemon=True
-    )
-    process.start()
-    process.join(timeout=4)
-    try:
-        assert process.exitcode == 124
-    finally:
-        if process.is_alive():
-            process.terminate()
-        process.join()
-
-
-@pytest.mark.parametrize(
-    "tier,mode,gpu",
-    [
-        ("flash", "txt", False),
-        ("flash", "ocr", True),
-        ("basic", "txt", True),
-        ("basic", "ocr", True),
-        ("basic", "auto", True),
-    ],
-)
-def test_route_matrix(monkeypatch, tier, mode, gpu):
-    """显式模式与 Basic 均不分类，防止 TXT 请求意外触发 OCR。"""
-    from mineru.parser import file_type
-
-    monkeypatch.setattr(file_type, "guess_suffix_by_path", lambda path: "pdf")
-    monkeypatch.setattr(
-        pdf_sidecar,
-        "classify_pdf",
-        lambda *args: pytest.fail("unexpected classification"),
-    )
-    assert pdf_sidecar.resolve_route("input.pdf", tier, mode, "").use_gpu is gpu
-
-
-@pytest.mark.parametrize("mode", ["txt", "ocr"])
-def test_auto_is_resolved_once(monkeypatch, mode):
-    """分类结果直接成为后续 parse 的显式模式。"""
-    from mineru.parser import file_type
-
-    calls = []
-    monkeypatch.setattr(file_type, "guess_suffix_by_path", lambda path: "pdf")
-    monkeypatch.setattr(
-        pdf_sidecar, "classify_pdf", lambda *args: calls.append(args) or mode
-    )
-    route = pdf_sidecar.resolve_route("input.pdf", "flash", "auto", "2-4")
-    assert route == pdf_sidecar.ParseRoute("flash", mode, mode == "ocr")
-    assert calls == [("input.pdf", "2-4")]
-
-
-@pytest.mark.parametrize("suffix", ["docx", "ofd", "html", "csv", "epub"])
-def test_native_formats_stay_cpu(monkeypatch, suffix):
-    """即使传入残留 Basic/OCR 选项，原生格式仍为 Flash CPU。"""
-    from mineru.parser import file_type
-
-    monkeypatch.setattr(file_type, "guess_suffix_by_path", lambda path: suffix)
-    assert pdf_sidecar.resolve_route(
-        "input", "basic", "ocr", ""
-    ) == pdf_sidecar.ParseRoute("flash", "txt", False)
-
-
-def test_image_auto_routes_gpu(monkeypatch):
-    """图片 auto 无需打开 PDF 即能确定 OCR 路由。"""
-    from mineru.parser import file_type
-
-    monkeypatch.setattr(file_type, "guess_suffix_by_path", lambda path: "png")
-    assert pdf_sidecar.resolve_route("input", "flash", "auto", "").use_gpu
-
-
-def test_cpu_entry_rejects_models():
-    """CPU sidecar 在导入 parser 前拒绝模型路径。"""
-    with pytest.raises(ValueError, match="Flash TXT"):
-        pdf_sidecar.parse_cpu(
-            "missing.pdf", tier="basic", ocr_mode="txt", page_range=""
-        )
-
-
-def test_mixed_pdf_classifies_selected_pages(tmp_path):
-    """混合 PDF 的文本页与空白页选区分别固定为 TXT/OCR，不能按整本文档误分流。"""
-    from reportlab.pdfgen.canvas import Canvas
-
-    path = tmp_path / "mixed.pdf"
-    canvas = Canvas(str(path))
-    for row in range(20):
-        canvas.drawString(
-            40,
-            780 - row * 25,
-            "This document contains selectable text for native PDF extraction.",
-        )
-    canvas.showPage()
-    canvas.showPage()
-    canvas.save()
-    assert pdf_sidecar.classify_pdf(str(path), "1") == "txt"
-    assert pdf_sidecar.classify_pdf(str(path), "2") == "ocr"
-
-
-def test_twenty_page_limit_is_enforced(tmp_path):
-    """真实 21 页输入默认截到 20 页，显式超限范围在 GPU 调用前被拒绝。"""
-    from reportlab.pdfgen.canvas import Canvas
-    from mineru.errors import InvalidRequestError
-
-    path = tmp_path / "long.pdf"
-    canvas = Canvas(str(path))
-    for _ in range(21):
-        canvas.drawString(40, 100, "Page")
-        canvas.showPage()
-    canvas.save()
-    assert pdf_sidecar.resolve_page_range(path, "", max_pages=20) == "1-20"
-    with pytest.raises(InvalidRequestError):
-        pdf_sidecar.resolve_page_range(path, "1-21", max_pages=20)
-
-
-def test_import_has_no_heavy_or_update_side_effects():
-    """全新解释器导入 spawn 入口不会导入模型、PDFium 或执行启动更新。"""
-    root = Path(__file__).resolve().parents[1]
-    subprocess.run(
-        [
-            sys.executable,
-            "-c",
-            "import sys, app, space_app, pdf_sidecar; "
-            "assert not {'mineru', 'torch', 'spaces', 'docvortex', 'bootstrap'} & sys.modules.keys()",
-        ],
-        cwd=root,
-        check=True,
-        timeout=20,
-    )
-
-
-def test_sidecar_device_is_cpu(monkeypatch):
-    """sidecar 初始化强制清除从主进程继承的两个 CUDA 选择。"""
-    monkeypatch.setenv("MINERU_DEVICE_MODE", "cuda")
-    monkeypatch.setenv("MINERU_TABLE_DEVICE", "cuda")
-    pdf_sidecar.initialize()
-    import os
-
-    assert (
-        os.environ["MINERU_DEVICE_MODE"] == os.environ["MINERU_TABLE_DEVICE"] == "cpu"
-    )
-
-
-def test_flash_txt_never_calls_gpu(monkeypatch):
-    """经客户端实际分派的 Flash TXT 不调用装饰后的 GPU 函数。"""
-
-    def fake_sidecar(fn, *args, **kwargs):
-        """返回预定 CPU 路由，并核实 parse 不会再次使用 auto。"""
-        if fn is pdf_sidecar.resolve_route:
-            return pdf_sidecar.ParseRoute("flash", "txt", False)
-        assert fn is pdf_sidecar.parse_cpu and kwargs["ocr_mode"] == "txt"
-        return "cpu result"
-
-    monkeypatch.setattr(space_app, "sidecar_call", fake_sidecar)
-    client = space_app.InProcessArtifactClient(
-        lambda *args, **kwargs: pytest.fail("GPU entered")
-    )
-    assert (
-        asyncio.run(
-            client.parse_file("input.pdf", tier="flash", ocr_mode="auto", page_range="")
-        )
-        == "cpu result"
-    )
-
-
-def test_cancellation_keeps_slot_and_context(monkeypatch):
-    """重复取消不能放行第二个 GPU 请求，to_thread 仍传播原请求上下文。"""
-    started, release = threading.Event(), threading.Event()
-    calls = []
-    visitor = ContextVar("visitor", default="missing")
-    monkeypatch.setattr(
-        space_app,
-        "sidecar_call",
-        lambda *a, **k: pdf_sidecar.ParseRoute("basic", "txt", True),
-    )
-
-    def gpu(*args, **kwargs):
-        """模拟无法被 asyncio 取消的同步 GPU 推理。"""
-        calls.append(visitor.get())
-        started.set()
-        assert release.wait(5)
-        return "done"
-
-    async def scenario():
-        """取消第一个调用后，第二个调用必须等待真正的同步推理结束。"""
-        visitor.set("visitor-1")
-        client = space_app.InProcessArtifactClient(gpu)
-        first = asyncio.create_task(client.parse_file("a", tier="basic", page_range=""))
-        assert await asyncio.to_thread(started.wait, 3)
-        first.cancel()
-        await asyncio.sleep(0)
-        first.cancel()
-        second = asyncio.create_task(
-            client.parse_file("b", tier="basic", page_range="")
-        )
-        try:
-            await asyncio.sleep(0.05)
-            assert calls == ["visitor-1"] and not first.done() and not second.done()
-        finally:
-            release.set()
-        with pytest.raises(asyncio.CancelledError):
-            await first
-        assert await second == "done"
-        assert calls == ["visitor-1", "visitor-1"]
-
-    asyncio.run(scenario())
-
-
-def test_parse_errors_are_wrapped(monkeypatch):
-    """真正解析阶段的错误统一转换为客户端错误，而非只包围 return。"""
-    from mineru.kit.gradio.client import V1ArtifactError
-
-    def fail(*args, **kwargs):
-        """模拟分类期间 PDFium 抛出的解析错误。"""
-        raise RuntimeError("broken PDF")
-
-    monkeypatch.setattr(space_app, "sidecar_call", fail)
-    client = space_app.InProcessArtifactClient()
-    with pytest.raises(V1ArtifactError, match="broken PDF"):
-        asyncio.run(client.parse_file("input", tier="basic", page_range=""))