# 单册崩了，前面 4 册的结果还算数吗：舞台灯光 CAD 批量遍历的断点续跑编排

## 一、问题：一批跑完不等于一件事做完

某区文化艺术中心舞台灯光施工图深化第一版，演艺中心 7 个分册：封面与施工说明、系统图、灯具布置图、箱盒布置图、调光柜接线图、强电管线图、弱电管线图。转出的 DXF 合计 435.65MB，单册最大 116.74MB。

我把这 7 册排成一队顺序跑，端到端 167.4 秒。跑完看着挺完整——7 册全部返回，每册都有实体数。但只要多问一句，这套流程就站不住了：

**第 5 册跑到一半抛异常，前面 4 册已经算出的结果怎么处理？**

朴素写法是 `try` 包一层，出错打印日志继续下一册。但这样跑完，你得到的是"6 册结果 + 1 条错误日志"，而这 6 册里哪些可信、哪些是在文件已被改动的情况下算的，没人说得清。更麻烦的是重跑：从头再跑一遍要 167 秒，而错的可能只是 1 册。

编排层要解决的不是"怎么跑得快"，是三件事：**单册失败不拖累整批、重跑只跑该跑的、每个结果都能追到它基于哪份文件。** 本文把这套东西在 WorkBuddy 里固化成可复用步骤，代码和数字都来自本地实测。

## 二、前置：先把"一次手工跑"摊平成工作单元

手工跑的时候，一册图是这样处理的：DWG 转 DXF → ezdxf 读 → 数实体 → 记一笔。这四步连在一起，跑完就忘，没有任何中间状态留存。

要编排，先得把这条流水线切成**以册为单位的工作单元**，每个单元独立产出、独立成败。切分标准很简单：一个单元出错，不影响其他单元的任何产出。

切完之后有三个东西必须显式定义，缺一个编排就不成立：

- **单元标识**：册名。不用序号——序号在增补分册时会错位，册名不会。
- **单元输入指纹**：转换件体积 + sha256。这一条决定了断点续跑能不能信。实测过一次差异：同一张 DWG 的两份转换件，817369 字节（sha256 前 12 位 `5dd474acb951`）与 817315 字节（`9bfb0e7fa697`），差 54 字节。只看"文件在不在"，这种差异永远发现不了。
- **单元终止条件**：正常完成、抛异常、超时。三种都要落盘，不能只记"成功/失败"两态——超时和异常的处理方式不一样，混成一类就没法自动决策。

环境就三样：Python 3.13.14、ezdxf 1.4.4、标准库。转换用本机既有的 ODA FileConverter 27.1.0。这里有个前置坑要先排掉：`accoreconsole` 通道在中文路径下报 `[Errno 22] Invalid argument`，ODAFileConverter 用脚本调用同样报 `[Errno 22]`、改手工调用才 `RC=0`。这两个失败看着像图纸坏了，实际是中文路径的调用缺陷。**编排之前不先判一次通道，后面所有"失败"都不可信。**

## 三、实现：把批处理拆成四段

在 WorkBuddy 里，这套流程我拆成四段固定步骤，每段有自己的输入和落盘产物。

**第一段，生成清单。** 扫目录拿到 7 册 DXF，逐册算体积与 sha256，写一份清单文件。这一段只读，随时可重跑。清单是全流程唯一的事实入口，后面任何一节都不许自己去 glob。

**第二段，单册执行。** 每册起一个独立子进程跑遍历，父进程只负责等和记。为什么必须是子进程而不是函数调用？因为 116MB 的 DXF 一旦解析时内存吃紧，同进程内会连带把父进程拉下水，而子进程崩了只是返回一个非零码。

**第三段，状态落盘。** 每册一个 JSON，含册名、输入指纹、开始结束时间、退出码、实体数、错误摘要。状态文件是断点续跑的唯一依据。

**第四段，汇总。** 读全部状态文件，输出一张表；缺册、超时、异常三类单独列出，不并进总数。

这四段在 WorkBuddy 里就是四个可复用的步骤，我把它交给 AI 智能体按批执行——智能体负责按清单挨个跑、按规则记状态、把异常册挑出来，不负责判断某个数字对不对。判断留给人。

## 四、脚本与命令：单册隔离、超时、断点续跑

下面这段是实际跑的编排器。核心是三件事：子进程隔离、按体积定超时、按指纹判断能否跳过。

```python
"""7 册批处理编排器：单册子进程隔离 + 按体积定超时 + 指纹校验断点续跑。"""
from __future__ import annotations

import hashlib
import json
import subprocess
import sys
import time
from pathlib import Path

DXF_DIR = Path("D:/work/dxf")
STATE_DIR = Path("D:/work/state")      # 每册一个状态文件
WORKER = Path("D:/work/traverse_one.py")   # 单册工作者，接收一个 DXF 路径
SHEETS = ["00-封面、施工说明", "01-系统图", "02-灯具布置图", "03-箱盒布置图",
          "04-调光柜接线图", "05-强电管线图", "06-弱电管线图"]

BASE_TIMEOUT = 60.0        # 基准超时（秒）
SECONDS_PER_MB = 1.2       # 实测约 0.4s/MB，留 3 倍余量


def fingerprint(path: Path) -> dict:
    h = hashlib.sha256()
    with path.open("rb") as fh:
        for chunk in iter(lambda: fh.read(1 << 20), b""):
            h.update(chunk)
    return {"size": path.stat().st_size, "sha256": h.hexdigest()}


def load_state(sheet: str) -> dict | None:
    p = STATE_DIR / f"{sheet}.json"
    return json.loads(p.read_text(encoding="utf-8")) if p.is_file() else None


def can_skip(sheet: str, fp: dict) -> bool:
    """只有指纹一致且上次是正常完成，才允许跳过。"""
    st = load_state(sheet)
    return bool(st and st.get("status") == "done" and st.get("input") == fp)


def run_one(sheet: str, dxf: Path, fp: dict) -> dict:
    size_mb = fp["size"] / 1024 / 1024
    timeout = BASE_TIMEOUT + size_mb * SECONDS_PER_MB

    t0 = time.perf_counter()
    try:
        proc = subprocess.run(
            [sys.executable, str(WORKER), str(dxf)],
            capture_output=True, text=True, timeout=timeout, encoding="utf-8",
        )
        status = "done" if proc.returncode == 0 else "failed"
        record = {
            "sheet": sheet, "input": fp, "status": status,
            "returncode": proc.returncode,
            "elapsed_s": round(time.perf_counter() - t0, 2),
            "stdout": proc.stdout.strip()[-2000:],
            "stderr": proc.stderr.strip()[-2000:],
        }
    except subprocess.TimeoutExpired:
        # 超时单独成一态，不和异常混在一起
        record = {
            "sheet": sheet, "input": fp, "status": "timeout",
            "returncode": None, "timeout_s": round(timeout, 1),
            "elapsed_s": round(time.perf_counter() - t0, 2),
        }
    STATE_DIR.mkdir(parents=True, exist_ok=True)
    (STATE_DIR / f"{sheet}.json").write_text(
        json.dumps(record, ensure_ascii=False, indent=2), encoding="utf-8")
    return record


def main() -> None:
    STATE_DIR.mkdir(parents=True, exist_ok=True)
    skipped, ran = [], []
    for sheet in SHEETS:
        dxf = DXF_DIR / f"{sheet}.dxf"
        if not dxf.is_file():
            print(f"[MISS] {sheet} 清单内无此文件")
            continue
        fp = fingerprint(dxf)
        if can_skip(sheet, fp):
            skipped.append(sheet)
            print(f"[SKIP] {sheet} 指纹未变，沿用上次结果", flush=True)
            continue
        rec = run_one(sheet, dxf, fp)
        ran.append(sheet)
        print(f"[{rec['status']:^7}] {sheet:<18} {rec['elapsed_s']:>6.2f}s", flush=True)

    print("-" * 60)
    print(f"本次实跑 {len(ran)} 册，跳过 {len(skipped)} 册")
    for sheet in SHEETS:
        st = load_state(sheet)
        if st is None:
            print(f"  缺状态 {sheet}")
        elif st["status"] != "done":
            print(f"  {st['status']:<7} {sheet}  <- 需单独处理")


if __name__ == "__main__":
    main()
```

上面这段里的 `WORKER` 不能悬空，它得是一个真的能单独跑起来的脚本。这是整套编排的地基——父进程只认它的退出码和 stdout，所以它必须做到「只处理一册、只输出一行 JSON、出错就用非零码退出」。

```python
"""traverse_one.py：单册工作者。用法 python traverse_one.py <dxf路径>
成功：stdout 打印一行 JSON，退出码 0；失败：stderr 打印原因，退出码非 0。
"""
from __future__ import annotations

import json
import sys
import time
from pathlib import Path

import ezdxf


def count(path: Path) -> dict:
    t0 = time.perf_counter()
    doc = ezdxf.readfile(str(path))

    model_n = sum(1 for _ in doc.modelspace())
    layout_n = 0
    layout_detail = {}
    for name in doc.layout_names():
        if name.lower() == "model":
            continue
        n = sum(1 for _ in doc.layout(name))
        layout_detail[name] = n
        layout_n += n

    return {
        "sheet": path.stem,
        "model": model_n,
        "layout": layout_n,
        "total": model_n + layout_n,
        "layout_detail": layout_detail,
        "seconds": round(time.perf_counter() - t0, 2),
    }


def main() -> int:
    if len(sys.argv) != 2:
        print("用法: traverse_one.py <dxf 路径>", file=sys.stderr)
        return 2

    path = Path(sys.argv[1])
    if not path.is_file():
        print(f"文件不存在: {path}", file=sys.stderr)
        return 3

    try:
        result = count(path)
    except Exception as exc:                      # 任何读图异常都转为非零退出
        print(f"{type(exc).__name__}: {exc}", file=sys.stderr)
        return 1

    print(json.dumps(result, ensure_ascii=False)) # 只输出一行，父进程直接解析
    return 0


if __name__ == "__main__":
    sys.exit(main())
```

这个脚本有三条设计约束值得说明。第一，**退出码分档**：2 是用法错、3 是文件不存在、1 是读图异常，父进程可以据此决定「跳过」「重试」还是「报人」。第二，**stdout 只放一行 JSON**，日志一律走 stderr——否则父进程解析输出时会被日志行污染。第三，**不认识"C:\ 前面有没有文件"这种事**，文件存在性由父进程在清单阶段就校验过，工作者只负责干活。

执行命令就一条：

```bash
python orchestrate.py
```

真实输出：

```
[ done  ] 00-封面、施工说明        0.36s
[ done  ] 01-系统图            30.39s
[ done  ] 02-灯具布置图          46.27s
[ done  ] 03-箱盒布置图          30.01s
[ done  ] 04-调光柜接线图          4.06s
[ done  ] 05-强电管线图          26.19s
[ done  ] 06-弱电管线图          30.08s
------------------------------------------------------------
本次实跑 7 册，跳过 0 册
```

第二次跑，7 册全部 `SKIP`，整批耗时不到 1 秒。这就是断点续跑的实际价值：**改一册只重跑一册，其余 6 册靠指纹认账。**

## 五、教训：编排层撞到的四个问题

### 一、返回 0 个实体，是成功还是失败

这册 00-封面、施工说明跑完返回 `model_total = 0`。如果编排器用"实体数大于 0"判成功，这册会被记成失败；如果用"退出码为 0"判成功，它会记成功——但只扫模型空间的话，它的真实实体数是 755，全在图纸空间 `Gb A2`。

编排层在这里必须补一条：**判定成败看退出码，判定内容完整性看"总实体 = 模型 + 全部图纸空间"这个式和不为 0。** 这两个判据不能合并。整批里有两册模型空间是 0（00 册和 04-调光柜接线图，后者 17951 个实体全在图纸空间），合并判据会把它们误杀或误放。

### 二、超时阈值不能写死成一个数

单册实测：0.78MB 用 0.36 秒，4.43MB 用 4.06 秒，116.74MB 用 46.27 秒。耗时贴着体积走，大约每 MB 0.4 秒。

如果给一个固定的 60 秒，116.74MB 那册只剩 14 秒余量，换台慢一点的机器就会假超时；如果给 300 秒，小册真卡死时你要白等 5 分钟。所以超时按体积算：`60 + 体积MB × 1.2`，留约 3 倍余量。**超时阈值不是安全参数，是容量参数，得跟着数据规模走。**

### 三、异常必须被隔离在单册内部

`ezdxf.readfile` 对 116MB 的 DXF，峰值内存是文件体积的好几倍。同进程里连续读 7 册，一旦某一册咬爆内存，整个进程连同前面已算出的结果一起没了。

这就是必须走子进程的原因。子进程崩了，父进程只收到一个非零返回码和一段 stderr，状态文件里记一笔 `failed`，其余 6 册的结果完好无损。代价是多进程启动的几十毫秒，换的是整批结果不陪葬。

### 四、断点续跑不能只看"结果文件在不在"

最省事的续跑判据是"结果文件存在就跳过"。这个判据在一种情况下会静默给出错误答案：**文件被改了，但结果文件还在。**

我这批就有真实案例。同一张图的两份转换件，817369 与 817315 字节，sha256 完全不同。如果只看结果文件存在，第二次统计会直接沿用第一次的数字，而两次数的根本不是同一份文件。实测里那一册台账记 17557、实测 17577，差 20——这 20 到底来自口径还是来自转换件版本，正因为上一轮没记指纹，现在只能挂着待查，查不下去。

**续跑判据必须是"指纹一致 + 上次正常完成"两个条件同时成立。** 少一个条件，续跑就会变成错误的放大器而不是效率工具。

## 六、结语：批处理的价值不在跑通，在崩了还能接着跑

7 册、435.65MB、109132 个实体、端到端 167.4 秒——这些数字只说明流程能跑。真正决定这套东西能不能长期用的，是另外三件事：

单册崩了，其余 6 册还在；文件改了，指纹会把它揪出来重跑；某一册超时，它单独成一态，不会伪装成"这册没内容"。

编排层做的事情，说到底只有一句：**把"一次跑完"变成"随时可以重跑，且每次都知道自己在跑哪一份文件"。** 前者靠运气，后者靠状态。


某区文化艺术中心舞台灯光施工图深化第一版，演艺中心 7 个分册：封面与施工说明、系统图、灯具布置图、箱盒布置图、调光柜接线图、强电管线图、弱电管线图。转出的 DXF 合计 435.65MB，单册最大 116.74MB。

单册崩了，前面 4 册的结果还算数吗：舞台灯光 CAD 批量遍历的断点续跑编排

7 册图纸顺序批处理，第 5 册崩了，前 4 册结果算什么？本文把 CAD 遍历编排成可复用步骤：单册子进程隔离、按体积定超时（0.78MB 用 0.36 秒、116.74MB 用 46.27 秒）、指纹校验断点续跑（7 册重跑全部跳过不到 1 秒）。含编排器与单册工作者两段可跑代码，并给出四个真实教训：返回 0 个实体不等于失败、超时是容量参数不是安全参数、异常必须隔离在单册内、续跑不能只看结果

人工智能

单册失败不影响其余结果，支持断点续跑与指纹校验。采用子进程隔离、超时自适应、异常独立落盘，确保文件变更可识别并重跑。基于SHA256与体积指纹，仅重跑改动册，其余沿用上次结果。实测7册共435.65MB、167.4秒完成，二次运行秒级跳过，适合CAD批量遍历的稳健编排。

代码解释

智能体

WorkBuddy 

JSON

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

单册崩了，前面 4 册的结果还算数吗：舞台灯光 CAD 批量遍历的断点续跑编排-腾讯云开发者社区-腾讯云

单册崩了，前面 4 册的结果还算数吗：舞台灯光 CAD 批量遍历的断点续跑编排

单册崩了，前面 4 册的结果还算数吗：舞台灯光 CAD 批量遍历的断点续跑编排

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐