From dbb264f6791097437bf653f7236ef9f5ac0ea4f7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=98=BF=E7=99=BD=E5=8F=94?= <11794527+absfan@user.noreply.gitee.com> Date: Tue, 17 Nov 2026 15:14:50 +0800 Subject: [PATCH 01/27] docs: record approved independent verification implementation plan --- ...7-independent-verification-new-features.md | 323 ++++++++++++++ .../2026-11-17-verification-development.md | 143 +++++++ ...ndependent-verification-business-design.md | 402 ++++++++++++++++++ 3 files changed, 868 insertions(+) create mode 100644 docs/superpowers/plans/2026-11-17-independent-verification-new-features.md create mode 100644 docs/superpowers/plans/2026-11-17-verification-development.md create mode 100644 docs/superpowers/specs/2026-11-17-independent-verification-business-design.md diff --git a/docs/superpowers/plans/2026-11-17-independent-verification-new-features.md b/docs/superpowers/plans/2026-11-17-independent-verification-new-features.md new file mode 100644 index 0000000..32fa4ad --- /dev/null +++ b/docs/superpowers/plans/2026-11-17-independent-verification-new-features.md @@ -0,0 +1,323 @@ +# 独立校验新增功能 Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use `superpowers:executing-plans` to implement task-by-task. All checkboxes are pending. Do not start implementation from the UI image alone or dispatch agents without user authorization. + +**Goal:** 新增可独立创建、接收成功结果、执行并让人复核的工程校验任务,交付 A 工作台及完整判断/失败处理。 + +**Architecture:** 在现有原生捕获、导出、图比较、回执证明之上增加校验领域包;任务、工程项、不可变输入版本、执行尝试与本次运行范围各有身份。界面只查持久事实和证据;统一输入接口不包含来源分类,批量与未来增量共用接口。 + +**Tech Stack:** Python 3.12、SQLite、PySide6、pytest/pytest-qt、已有 Native CLI/OwnedCliScope/ServiceWorker/LatestQuery;标准库 JSON/HTML,无新运行时依赖。 + +**Spec:** [业务、流程、状态、数据与失败处理](../specs/2026-11-17-independent-verification-business-design.md)。对应用户最终选择的 A 图片入口,不采用此前带来源或流水线横条的旧草案。 + +用户已确认业务方向,开发阶段、工作区隔离、跨任务接口和交付门槛统一从[开发与交付入口](2026-11-17-verification-development.md)读取。本文件是该入口下的逐任务清单,仍全部待实施。 + +## Global Constraints + +- 只开发当前没有的功能;不接手 issue29 收尾、既有任务列表或其他并行修复。 +- 原始捕获、原生导出、覆盖核验与绑定实际回执的预期解析直接复用;不重写旧替换状态机。 +- 独立任务始终可创建;资源忙只影响执行领取,不影响新建和输入登记。 +- 无 source/type/mode 来路字段或来源筛选;没有预期清单不等于所有变化均被允许。 +- 当前只在已落盘结果后批量交接;增量接口和乱序规则先做好,不修改替换侧实时刷新。 +- 所有工作只读固定输入;禁止重新换料、自动换脚、修改库或把当前工程补造为旧 before。 +- 位号/物理脚号/连接严格;引脚文字变化与器件 Value、网络名分开;未知字段不能冒充一致。 +- “执行成功”与“工程结论”分开;必查未知不能通过,已知异常不被警告或未知覆盖。 +- 同一输入版本只允许一个活动尝试;新版本不替换在跑输入,迟到结果不能覆盖当前结论。 +- GUI 不进行 CAD/CLI/磁盘全图扫描;延用既有风格、980×700 最小窗口与1280×880默认窗口。 +- 新增原生进程只使用现有 OwnedCliScope;退出无法确认时暂停该执行器,不触发旧 CAD 退出/恢复动作。 +- 清理不能删除活动/当前引用的快照、证明和报告;Git不接收客户工程、原始网表或厂商二进制。 +- 每个任务独立测试/审阅/提交;只暂存其明确文件,保护工作区并行修改。实现前按最新主线重新定位接口。 + +## 0. 文件划分与依赖 + +领域包新建于 `src/dx_productivity/trial_task_center/verification/`,以下缩写 `V/` 指该目录;`UI/` 指既有 `src/dx_productivity/trial_task_center/ui/`。测试使用完整仓库相对路径。 + +| 文件 | 职责 | 首次任务 | +| --- | --- | --- | +| `V/__init__.py`、`V/contracts.py` | 输入/检查/状态合同,结果汇总 | N01 | +| `V/store.py` | 校验任务、工程、版本、尝试、运行、命令去重事务 | N02 | +| `V/service.py` | 本域公开接口,接收/查询/执行薄编排 | N03 | +| `V/intake.py` | 稳定导入、版本接收、成功交接适配 | N03 | +| `V/queries.py` | 当前版本投影、分页与统计 | N04 | +| `V/runner.py` | 独立只读执行器、资源准入与发布 | N05 | +| `V/rules.py` | J01~J13 分维度判断与事实差异 | N06 | +| `V/pin_metadata.py` | 已验证原生字段适配、能力与未覆盖清单 | N07 | +| `V/evidence.py` | issue 定位、端点差异与确定性图数据 | N08 | +| `UI/verification_workspace.py` | 页面、任务选择、工程表、底栏 | N09 | +| `UI/verification_controller.py` | 异步查询、选择代次和用户命令 | N09 | +| `UI/verification_inspector.py` | 逐脚对照、事实表、范围与证据入口 | N09 | +| `V/report.py` | 同一证据包的HTML/JSON和整任务导出 | N11 | +| `tools/verify_independent_verification.py` | 受控/真实只读验收CLI,明确区分两种证据 | N12 | + +新增 schema 由现有 `store_schema.py` 的版本升级入口调用 `V/store.py`,原服务 `service.py` 只暴露本域服务引用,不继续堆叠校验业务。 + +依赖:N01→N02→N03→N04;N02/N03→N05;N01→N06;N05/N06→N07→N08;N04/N05/N08→N09;N05/N09→N10→N11→N12。 + +N05 可以先用已有比较器返回原始事实和明确覆盖,N06 增加分级,N07 丰富引脚元数据;能力未验证的阶段必须产生 unknown,不为界面测试假造通过。 + +## N01:固定输入、执行状态与结论合同 + +**Files:** Create `V/__init__.py`、`V/contracts.py`;Test `tests/v1_1/test_independent_verification_contracts.py`。 + +**Interfaces:** `validate_input(value: dict) -> dict`;`rollup_results(checks: tuple[dict, ...], *, required_checks: tuple[str, ...], optional_checks: tuple[str, ...] = ()) -> dict`。返回 verdict、coverage、warnings/errors/unknown计数及 scope。missing required check 等同 unknown;空检查不能一致,空required_checks拒绝为非法检查计划。`CheckResult` 用字典并严格校验 check_id/state/issues/evidence_refs,不新增泛型框架。 + +检查ID固定:inputs(J01)、coverage(J02)、components(J03)、physical_pins(J04)、connections(J05/J06)、net_names(J07)、declared_attributes(J08)、attribute_changes(J09)、pin_text(J10)、pin_semantics(J11)、footprint_mapping(J12)、export_identity(J13)。同一check有多个issue,不重复check_id;无expectation时declared_attributes不能伪装已检查,attribute_changes仍输出变化事实。 + +- [ ] 写空结果、缺必查、错误与未知并存、警告、可选未知、无预期清单的失败测试: + +```python +def test_empty_checks_do_not_prove_consistency(): + from dx_productivity.trial_task_center.verification.contracts import rollup_results + result = rollup_results((), required_checks=('connections',)) + assert result['verdict'] == 'INCOMPLETE' + assert result['coverage'] == 'partial' +``` + +- [ ] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_independent_verification_contracts.py -q`,确认新合同尚不存在而失败。 +- [ ] 实现严格字段、枚举、摘要、整数版本与受管引用结构校验;拒绝外部任意输出路径,UI不传来源字段。输入字段按规范4.1,check_plan明确 required/optional/excluded。 +- [ ] 实现纯汇总优先级,核心逻辑固定为: + +```python +if any(row['state'] == 'error' for row in checks): + verdict = 'DIFFERENT' +elif any(states.get(key, 'unknown') not in {'equal', 'expected_change', 'warning'} + for key in required_checks): + verdict = 'INCOMPLETE' +elif any(row['state'] == 'warning' for row in checks): + verdict = 'WARNING' +else: + verdict = 'CONSISTENT' +``` + +`states` 在同函数中由唯一 check_id 建立;重复check_id拒绝,不用后值覆盖前值。必查项被标not_requested同样不能通过;空required_checks在该分支前抛出TaskCenterError。覆盖清单独立计算。 + +- [ ] 重跑本组,补 actual属性值不能反推expected、not_requested不计已检查、没有规则时scope文字不能“换料符合”的断言。 +- [ ] 对照规范J01~J13与状态表自审字段;保留原始文字及证据引用,不在合同层猜测引脚功能。 +- [ ] Commit `feat: define independent verification contracts and verdicts`。 + +## N02:任务、版本、尝试与去重事务 + +**Files:** Create `V/store.py`;Modify `src/dx_productivity/trial_task_center/store_schema.py`;Test `tests/v1_1/test_independent_verification_store.py`。 + +**Interfaces:** `VerificationRepository(task_store)`:`create_task(name: str, *, request_id: str) -> dict`、`publish(task_id: str, inputs: tuple[dict, ...], *, submission_id: str) -> dict`、`create_attempt(item_id: str, version: int, *, request_id: str) -> dict`、`claim(attempt_id: str, *, owner_id: str) -> dict`、`finish(attempt_id: str, *, generation: int, result: dict) -> bool`。这些只操作已验证的领域记录;原生I/O由服务完成。 + +- [ ] 写旧DB升级、创建去重、同版不同正文、乱序、唯一活动尝试、迟到finish与并发claim测试。测试内创建真实临时TaskStore: + +```python +def test_new_task_does_not_require_replacement_task(tmp_path): + from dx_productivity.trial_task_center.store import TaskStore + from dx_productivity.trial_task_center.verification.store import VerificationRepository + with_store = TaskStore(tmp_path / 'tasks.db') + try: + repo = VerificationRepository(with_store) + first = repo.create_task('电源板核对', request_id='create-1') + again = repo.create_task('电源板核对', request_id='create-1') + assert first['task_id'] == again['task_id'] + finally: + with_store.close() +``` + +- [ ] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_independent_verification_store.py -q`,确认失败。 +- [ ] 建 verification_tasks/items/input_revisions/attempts/runs/requests 表,状态只属于本域;给版本和请求去重键唯一索引。至少固定: + +```sql +CREATE UNIQUE INDEX verification_input_identity +ON verification_input_revisions(item_id, input_version); +CREATE UNIQUE INDEX verification_active_attempt +ON verification_attempts(item_id, input_version) +WHERE state IN ('queued','running','publishing','stopping'); +``` + +- [ ] 实现事务内版本指针移动、逐条接收和CAS generation;批量外层错误全拒绝,逐项错误返回原因,已接收其他项不回滚。保存request摘要,拒绝同request_id异文。 +- [ ] 用真实临时SQLite跑本组及既有schema/store回归;核对旧execution_operations与重试额度字节/行值未被新操作改写。 +- [ ] 故障注入提交前/提交后;返回值在事务内准备,不能因COMMIT后的额外尾读失败误报未接收;记录同一 before 新after与新before分项的区别。 +- [ ] Commit `feat: persist verification tasks inputs and attempts`。 + +## N03:统一接收、独立导入与成功结果交接 + +**Files:** Create `V/service.py`、`V/intake.py`;Modify `src/dx_productivity/trial_task_center/service.py` 仅暴露 `verification` 服务;接入 `dsh/execution_runs.py` 的已持久结果通知,不修改其执行/恢复合同;Test `tests/v1_1/test_independent_verification_intake.py`。 + +**Interfaces:** `VerificationService(task_store, data_root: Path)`;`create_task(name, *, request_id)`;`publish_inputs(task_id, inputs, *, submission_id)`;`import_pair(task_id, before: Path, after: Path, *, request_id: str, stop_event) -> dict`;`receive_successful_results(result_ref: dict, *, submission_id: str) -> dict`;`reconcile_deliveries(*, limit: int = 100) -> dict`。两种操作最终发布同一种inputs,无来路枚举。默认自动接收容器名为“校验任务”,以持久交接关联键去重,用户可改名。 + +- [ ] 写两份工程同文件/数据库别名、捕获时变化、成功交接缺before、未成功结果拒绝、重复交接、一次批量和分次输入等价的测试。自建文件只用于事务/捕获测试,不假称可打开CAD工程。 +- [ ] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_independent_verification_intake.py -q`,确认失败。 +- [ ] 复用capture_project,受管目录外输入先检查稳定性;两个文件最终数据库同源也要拒绝。已冻结交接只核验引用,不打开原CAD或重新捕获旧before。 +- [ ] 对已落盘成功范围建规范inputs;expectation_ref来自冻结清单/有效回执,不用after反推。补有界交接对账:首次接收和重启/进入校验页重扫未确认通知都用同submission键,落库回执作为完成依据。 +- [ ] 重跑本组;让导入/发布期间的替换和恢复入口抛AssertionError,证明只创建校验记录。成功工程缺证据仍可见,错误输入不能将旧baseline换成当前工程。 +- [ ] 对照接口确认当前能批量传、未来能乱序增量传;输入接收不创建queued尝试,不强制切走用户正在看的任务。 +- [ ] Commit `feat: receive verification inputs and import project pairs`。 + +## N04:当前版本查询、任务统计与历史投影 + +**Files:** Create `V/queries.py`;Modify `V/service.py`;Test `tests/v1_1/test_independent_verification_queries.py`。 + +**Interfaces:** `list_tasks(*, query='', cursor=None, limit=50, read_control=None)`;`read_task(task_id, *, state='', query='', cursor=None, limit=100, read_control=None)`;`read_item(item_id, *, version: int | None = None, read_control=None)`;`read_issues(attempt_id, *, kind='', cursor=None, limit=100, read_control=None)`。返回task view_revision、当前input_version、attempt身份、结论、范围、动作门禁、分页cursor。`summarize_items(rows)`只统计当前版本。 + +- [ ] 写24项计数、旧版不重复计数、重校验转排队后旧绿灯退出当前、同名不同身份、筛选与整任务操作范围分离的测试。 +- [ ] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_independent_verification_queries.py -q`,确认失败。 +- [ ] 实现“输入→当前尝试→结论→可执行动作”的单一投影;执行succeeded且verdictDIFFERENT必须显示异常,而非通过。空任务可新建/加工程,活动任务不禁用创建其他任务。 +- [ ] 参数化查询实现50任务/100工程/100问题上限,搜索名称、路径及已有issue位号/料号;转义LIKE的百分号/下划线。分页cursor绑定过滤、排序和view_revision,身份不从行号推断。 +- [ ] 跑本组与既有任务只读查询测试,核对“24=16一致+2警告+1异常+1无法校验+4待校验,已处理20”;暂停/中断单列不当一致。 +- [ ] 用并发读/新版本发布验证快照计数一致;旧attempt结果只进入历史,不刷新当前绿色。 +- [ ] Commit `feat: query current verification results and task summaries`。 + +## N05:独立只读执行器与原生后端适配 + +**Files:** Create `V/runner.py`;Modify `netlist_verification.py` 仅暴露固定输入导出缓存适配,原调用保持;Modify `V/service.py`、`V/store.py`;Test `tests/v1_1/test_independent_verification_runner.py`;Regression `test_netlist_execution.py`、`test_pr27_netlist_pause.py`。 + +**Interfaces:** `run_attempt(service, attempt_id: str, *, stop_event) -> dict`;`export_inputs(before_ref: dict, after_ref: dict, *, output: Path, stop_event) -> tuple[dict, dict]`;`can_start_native_export(service) -> dict` 返回allowed/reason,不占用新建入口。N06前本适配可返回已有比较事实并显式缺少扩展检查,不能编造完整结论。 + +- [ ] 写任意独立任务可运行、原输入不变、缺工具不启动CAD、旧缓存损坏重导出、并发领取唯一、资源忙排队的测试。runner用受控OwnedCliScope/现有graph夹具,实际持久库和文件发布链不替换为固定成功值。 +- [ ] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_independent_verification_runner.py -q`,确认失败。 +- [ ] 依照E03~E07核验固定引用;捕获/导出只走既有native_netlist。首版独立runner一次领取一个工程对,前后导出顺序运行,避免复制旧批次pool再叠加并发。若原生资源准入不可证明可并行,则留队列等待;不以该等待禁用新建。 +- [ ] 组织比较调用与暂存产物;先按E10确认自有CLI退出,再按E11发布结果及CAS finish。原异步导出/旧finish行为不被替换为新全局队列,接收既有完整证据时可以只复核/复用而不额外开进程。 +- [ ] 跑新组及两个旧网表组;断言替换派发数、CAD启动数、execution_operations写次数均为0,旧入口的暂停与缓存合同不退化。 +- [ ] 注入导出失败和发布中断;确认旧结果不覆盖、迟到attempt不更新当前。记录新执行器与旧资源修复的责任边界,不用本任务修退出helper。 +- [ ] Commit `feat: execute independent verification on immutable inputs`。 + +## N06:结构、属性、警告与未知的逐项判断 + +**Files:** Create `V/rules.py`;Modify `V/runner.py`;Test `tests/v1_1/test_independent_verification_rules.py`。 + +**Interfaces:** `evaluate(before: dict, after: dict, *, expectations: dict | None, check_plan: dict, pin_metadata: dict | None = None) -> dict` 返回checks、issues和N01汇总;`match_components(before_graph, after_graph) -> dict`返回可证明对应及歧义,不改原图。没有expectations与有意声明空变化清单须区分。 + +- [ ] 用真实最小graph夹具写J01~J13反例:断线、短接、交换物理脚、位号增删、用户网名、无清单属性、正常目标变化、非目标变化、命名警告、必查unknown。固定脚号互换测试独立于名称相似度。 +- [ ] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_independent_verification_rules.py -q`,确认失败。 +- [ ] 复用已有完整图/物理端点语义,建立只读对应视图;延用最新实例范围+生效位号唯一绑定,UID仅保留原始证据,其缺失/重复/变化不得否定已证明的位号对应。真实位号/实例歧义仍unknown。连接按完整端点集合比较,单端网络与未连接不混用。 +- [ ] 按check输出事实,不直接复用旧verified作为新最终结论;对允许改名的原比较结果补warning。关键边界为: + +```python +if numbers_equal is False or connections_equal is False: + pin_text_state = 'error' +elif numbers_equal is not True or connections_equal is not True or pin_text_changed is None: + pin_text_state = 'unknown' +elif pin_text_changed: + pin_text_state = 'warning' +else: + pin_text_state = 'equal' +``` + +该片段只在物理脚已建立对应后运行;结构或连接已证明改变仍按硬异常处理,未证明的比较结果不会被Python的假值语义误判为“已证实改变”。unknown字段不由空字符串补齐,GND/VCC语义不由模型判断。 + +- [ ] 跑本组及现有physical pin/逻辑改名测试;证明默认旧比较器结果不被全局放宽,网名变化不会套入引脚名称规则。 +- [ ] 检查错误优先、未知必查、警告、范围一致四类;有已知反脚加缺失属性时仍DIFFERENT,同时保留unknown列表。 +- [ ] Commit `feat: classify verification checks with explicit evidence and coverage`。 + +## N07:引脚级字段与封装映射能力探测 + +**Files:** Create `V/pin_metadata.py`、`tools/probe_verification_pin_metadata.py`、`docs/research/2026-11-17-pin-metadata-capability.md`;Test `tests/v1_1/test_verification_pin_metadata.py`;Modify `V/runner.py`。 + +**Interfaces:** `inspect_pin_metadata(export: dict, *, evidence_root: Path) -> dict` 返回每物理脚的logical_name/pin_value/electrical_type字段、存在性、原始定位、confidence为proven/unknown;`inspect_footprint_mapping(binding: dict) -> dict` 首版只接纳真实可证适配,未支持返回unknown及原因,不用空字典代表映射相同。 + +- [ ] 写引脚Value与器件Value不同、原字段缺失、引脚类型变化、逻辑名对齐物理号、库映射未知的测试。缺证据边界: + +```python +def test_missing_mapping_is_unknown(tmp_path): + from dx_productivity.trial_task_center.verification.pin_metadata import inspect_footprint_mapping + result = inspect_footprint_mapping({'symbol': 'example', 'cell': 'example', 'evidence': None}) + assert result['state'] == 'unknown' + assert result['mapping'] is None +``` + +- [ ] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_verification_pin_metadata.py -q`,确认失败。 +- [ ] 探针只在用户工程已保存副本/受管导出上读取现有原生输出,记录确切字段、版本、存在性和物理脚绑定。先确认能否读出,不能凭类型名发明COM方法或回退CAD采集;探针不直接进入生产导入链。 +- [ ] 只有已证明的字段进入最小解析适配;无引脚Value就保留unknown,不用逻辑名或器件Value代替。库内映射默认未覆盖,只有取得真实版本/符号/Cell/脚号证据才实现对应分支。 +- [ ] 运行本组及N06,使用自建可提交fixture覆盖loop/outloop、同号不同文字、同名不同脚和已证实映射交换;客户报告只本地保存,仓库仅自建摘录。 +- [ ] 写能力报告:已验证字段/格式、未覆盖项、真实读取或纯夹具证据;无法验证的能力不阻止A基础页交付,但必查请求该能力时必须INCOMPLETE。 +- [ ] Commit `feat: expose proven pin metadata and unsupported mapping coverage`。 + +## N08:可人工复核的证据模型与连接图 + +**Files:** Create `V/evidence.py`;Modify `V/runner.py`;Test `tests/v1_1/test_verification_evidence.py`。 + +**Interfaces:** `build_evidence(before_graph: dict, after_graph: dict, issues: tuple[dict, ...], *, binding: dict) -> dict` 返回issue稳定ID、前后物理脚位置、连接对端、差异表和raw定位。`connection_view(evidence: dict, issue_id: str) -> dict` 只生成确定性绘图数据,不调用图片/语言模型。 + +- [ ] 写R12 1/2互换、短接多对端、纯改名不画红断线、未知映射、图页未知与证据摘要损坏测试。前后pin1的绘制顺序必须相同,不能自动互换位置使图看起来一致。 +- [ ] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_verification_evidence.py -q`,确认失败。 +- [ ] 从N06事实产生唯一issue_id;图和表共享同一数据结构,不分别拼判断。端点按固定脚号排列,变化线给出added/removed及原网络名,保留多gate与实例身份。 +- [ ] 将issue绑定不可变raw文件、摘要与可定位段落/对象键;图页无法确定则明确未定位。图标注“由网表生成”,不画伪原理图截图,不用生成模型解释电气正确性。 +- [ ] 跑本组与N06;反例断言每条红色连线都有对应连接error/差异,纯文字warning没有虚构接线变化。 +- [ ] 检查独立输入无expectation时证据仍可读;原生身份列差异与有效料号显示分开,不改写raw以统一数值。 +- [ ] Commit `feat: build traceable pin and network comparison evidence`。 + +## N09:A工作台、独立新建与证据检查器 + +**Files:** Create `UI/verification_workspace.py`、`UI/verification_controller.py`、`UI/verification_inspector.py`;Modify `UI/main_window.py`、`UI/icons.py`,样式仅加本页控件选择器;Test `tests/ui/test_verification_workspace.py`、`test_verification_inspector.py`。 + +**Interfaces:** `VerificationWorkspace(service, parent=None)`;`open_task(task_id, item_id=None)`、`set_active(active)`、`shutdown()`、`busy`、`busy_changed`;`VerificationInspector.set_evidence(evidence)`。controller通过N04查询,未来增量输入仅更新结果查询,不重新设计来路入口。 + +- [ ] 写四导航映射、始终可新建、已有任务时独立导入、无来源横条、选择保持、不同任务延迟回调、DIFFERENT不显示通过的Qt测试。沿用既有`ui` fixture,但不更改其修复逻辑。 +- [ ] Run `.venv/Scripts/python.exe -m pytest tests/ui/test_verification_workspace.py tests/ui/test_verification_inspector.py -q`,确认失败。 +- [ ] 按最终图建立任务列表/状态筛选/工程表/右证据/固定底栏;main_window按页面对象明确映射四导航,DSH懒加载不被触发。新建对话框只含名称与可选前后工程,不要求来源选择。 +- [ ] QPainter或Qt原生控件渲染N08确定性图,表格同源;保持8–12px圆角、白色数据面、已有亚克力外框和减少透明度设置。980宽改可展开详情,不遮住开始/停止按钮。 +- [ ] 跑本组、现有history/DSH导航与样式测试;无后台run时点击导航或选工程只查询,不隐式导出。 +- [ ] 人工看1280×880、980×700及125/150%缩放;右侧R12对照保持1/2位置,警告/未知文字可读。静态图片仅视觉参考,不算功能验收。 +- [ ] Commit `feat: add the independent verification workspace and evidence inspector`。 + +## N10:开始、停止、重校验、崩溃恢复与版本竞争 + +**Files:** Modify `V/service.py`、`V/store.py`、`V/runner.py`、`UI/verification_controller.py`、`UI/main_window.py` 仅校验生命周期;Test `tests/v1_1/test_verification_control.py`、`tests/ui/test_verification_control.py`。 + +**Interfaces:** `start(task_id, *, selection: tuple[tuple[str,int], ...] | None, request_id)`,None表示服务端冻结当前全部ready;`stop(run_id, *, request_id)`;`rerun(item_id, version, *, request_id)`;`recover() -> dict`;`begin_shutdown()`。停止/恢复均不调用替换停止/准备重试/核验恢复函数。 + +- [ ] 写重复点击、冻结范围不吞新项、当前v2不被v1完成覆盖、取消与提交竞争、进程退出未知、重启不自动执行的测试。queued取消保留历史;整run停止前从未派发项投影回待校验,用户单项取消显示已停止。 +- [ ] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_verification_control.py tests/ui/test_verification_control.py -q`,确认失败。 +- [ ] 实现命令幂等与持久stop_requested;领取前/后、原生导出阶段和发布CAS前检查。终态提交先发生时保留真实结果;取消先发生时旧callback不能提交当前结果。 +- [ ] 实现重启核实OwnedCli身份/退出、F15产物补提交和interrupted;归属核对使用原owner/token/进程创建身份,不仅凭PID,以免PID复用误杀外部进程。未知资源留stopping,禁止盲目新导出。新attempt递增generation,旧terminal不改回running。 +- [ ] 跑本组及旧网表暂停组;在全部校验控制测试中将既有替换动作设为抛AssertionError,证明不会触发。GUI关闭不join/wait原生进程,通知安全结束后再关闭。 +- [ ] 受控慢导出期间切页、建新任务和停止,验证事件循环可响应;新工程后到保持待校验,不无限扩展当前run范围。 +- [ ] Commit `feat: control and recover independent verification attempts`。 + +## N11:完整报告、历史与证据保留 + +**Files:** Create `V/report.py`;Modify `V/service.py`、`UI/verification_controller.py`、`retention.py` 仅保护校验引用,复用HistoryRepository;Test `tests/v1_1/test_verification_reports.py`、`tests/ui/test_verification_report_actions.py`;Create `docs/user/independent-verification.md`。 + +**Interfaces:** `render_item_report(result_ref: dict, destination: Path) -> Path`;`export_task(task_id, destination: Path, *, request_id)`;`open_evidence(attempt_id, artifact_id)`只接受受管artifact标识。导出冻结view_revision,可在运行中生成并明确未完成项。 + +- [ ] 写同版本报告/图表一致、HTML转义、原证据损坏、导出重名、运行中快照、清历史不删证据、缓存不可伪装新结果的测试。 +- [ ] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_verification_reports.py tests/ui/test_verification_report_actions.py -q`,确认失败。 +- [ ] 从N08证据包渲染HTML/JSON,字段转义,原始文件只引用或用户明确选择后打包;默认不复制整个工程。报告固定输入/策略/工具/attempt摘要与检查范围。 +- [ ] 暂存→完整性核验→原子发布,重名目录明确错误不混写;HistoryRepository用稳定source_key防重复记录校验事件,此source_key为事件去重而非UI来源类型。 +- [ ] 跑本组与retention/history回归,核对当前/活动引用不可被普通日志清空删除,失去证据时显示不可用而非缓存绿灯。 +- [ ] 写用户说明:新建/自动接收无需来源、开始范围、警告/异常/未知、版本更新、停止重启、对照图与证据查看;不宣称ERC/PCB已检查。 +- [ ] Commit `feat: export verification evidence and preserve result history`。 + +## N12:集成、真实只读输入、包内入口与发布门禁 + +**Files:** Create `tools/verify_independent_verification.py`、`tests/v1_1/test_independent_verification_acceptance.py`、`tests/ui/test_verification_acceptance.py`、`docs/testing/2026-11-17-independent-verification-acceptance.md`;Modify `packaging/DxPartReplace.spec`及打包测试只在确有静态遗漏时,保护现有本地变更。 + +**Interfaces:** CLI `--fixture-root ... --output ...` 与 `--native-before ... --native-after ... --output ...` 明确分开;后者只读两份合法已保存工程,不执行换料。原有真实新换料闭环由已有执行器/验收工具交接,本任务只验证新校验任务能接收和复核,不重做其他任务的修复。 + +- [ ] 用真实临时SQLite、受控CLI和完整文件发布链建立端到端用例:两份工程创建、批量成功交接、增量乱序、24工程计数、命名警告、反脚、缺基线、停止、重启、v1/v2竞争、报告。每用例记录实际派发与原工程摘要,不用单纯固定绿灯填页面。 +- [ ] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_independent_verification_acceptance.py tests/ui/test_verification_acceptance.py -q`,确认缺口;前置已全部实现时允许首跑通过,不为制造red破坏实现。 +- [ ] 实现验收CLI串联公开接口并非零退出失败,记录模型图片仅参考、新功能真实证据另存。真实只读副本上复核引脚字段与层级范围;未知范围保持未知,不修改源工程制造反例。 +- [ ] 运行全部新增组、现有网表/BOM/导航/关闭/DSH及打包回归;再按仓库默认配置运行默认suite一次。记录当前分支并行修复是否已合入,不能冒用旧108项或旧EXE结果。 +- [ ] 在实际包中验证四导航、缺CAD工具仍可新建/导入记录/看已有报告、正确unavailable、正常关闭;不携带厂商exe和客户fixture。若可用真实本次成功回执,验证自动交接与手工独立输入共存且零重复换料。 +- [ ] 输出验收矩阵每项结果、通过数量、精确构建/输入/策略摘要、失败现场和未测范围;未取得真实引脚Value/映射证明时保留未覆盖声明。 +- [ ] Commit `test: accept independent verification tasks and evidence workflows`,功能完成后再走集成/发布决策;本计划不授权发布。 + +## 1. 场景到任务的验收映射 + +| 场景 | 必须满足 | 任务 | +| --- | --- | --- | +| 前面已有替换任务,仍新建独立校验 | 新建不依赖或覆盖换料任务,不要求来源 | N02/N03/N09 | +| 成功结果批量与分次传入 | 当前数据相同,重复与旧版不派发 | N02/N03 | +| 校验运行时收到新版本 | 旧输入固定,旧结果历史,新版待校验 | N02/N04/N10 | +| R12 1/2连接互换 | DIFFERENT,固定脚号图与逐脚表同源 | N06/N08/N09 | +| loop→outloop且结构不变 | WARNING,不能直接无提示通过 | N06/N07 | +| 缺引脚字段或库内映射 | unknown/未覆盖,必查未知不通过 | N01/N07 | +| 只有网名变 | 拓扑与名称分别显示,不套引脚改名放行 | N06 | +| 无清单两份工程 | 可比较,不能说换料规则符合 | N01/N03/N06 | +| CLI/解析/证据失败 | 明确原因,安全收尾后继续,未知资源暂停 | N05/N10/N11 | +| 关闭/崩溃/迟到回调 | 不重做换料、不污染新尝试,重启不自运行 | N10 | +| 图、表、报告、raw | 同一输入/issue/attempt,能追溯 | N08/N11 | +| 24项及1000工程规模 | 当前版本计数正确,100行有界读取,事件循环可响应 | N04/N09/N12 | + +## 2. 分段交付与未实现边界 + +1. N01~N04:可以创建、接收和查询独立任务,先不宣称校验完成。 +2. N05~N08:可独立执行、输出分级结论与人工证据;无法读取的字段保留unknown。 +3. N09~N11:最终A页面、控制、报告与历史完整可用。 +4. N12:真实输入、包内入口和默认回归满足后才声明交付。 + +共12个新增功能任务、84个复选步骤,均待执行。本文不是把旧计划未完成项全部重做:原生后端、非阻塞换料和当前修复仍沿用已有成果。未来替换实时推送、自动启动开关、未知电气语义字典、库映射扩展和自动修复均不作为首版暗含承诺。 diff --git a/docs/superpowers/plans/2026-11-17-verification-development.md b/docs/superpowers/plans/2026-11-17-verification-development.md new file mode 100644 index 0000000..12f96d4 --- /dev/null +++ b/docs/superpowers/plans/2026-11-17-verification-development.md @@ -0,0 +1,143 @@ +# 工程校验功能开发与交付计划 + +> **For agentic workers:** REQUIRED SUB-SKILL: Use `superpowers:executing-plans` with the linked N01~N12 detailed plan. This is the delivery entry point, not authorization to begin application changes. All development tasks are pending. + +**Goal:** 开发独立校验任务、可信判断和可人工复核的 A 工作台,复用现有能力,只增加缺失功能。 + +**Architecture:** 按“任务数据 → 独立校验 → 人工证据 → 页面与操作 → 验收”顺序交付。任务、工程输入版本、执行尝试分开持久化;统一接收接口适配当前批量交接和未来增量推送;判断、图、表和报告共享一份事实。 + +**Tech Stack:** Python 3.12、SQLite、PySide6、现有原生网表CLI与进程归属机制、pytest/pytest-qt;不新增运行时依赖。 + +**Spec:** [已确认业务设计及六张流程/状态图](../specs/2026-11-17-independent-verification-business-design.md)。逐文件接口、测试命令和提交步骤见 [N01~N12 开发清单](2026-11-17-independent-verification-new-features.md)。 + +## Global Constraints + +- 只做新增功能,不接手其他任务的退出、资源回收、工程统一提交或任务徽标修复。 +- 任何时候可新建校验,不展示或要求选择来源,不加换料流水线横条。 +- 当前接收已提交成功结果;增量、去重和版本接口做好,但本轮不开发替换实时刷新。 +- 使用固定前后副本;不自动换脚、不重新换料、不写原工程或库。 +- 位号/物理脚号/连接严格;引脚文字变化单独警告;缺证据明确未知。 +- 工具判断、人工接线图、事实表、报告绑定同一工程版本和同一次尝试。 +- 每任务先验证失败用例、最小实现、相关回归、自审和单独提交。功能完成前不发布。 + +## 1. 开工前处理 + +现在共享工作区的公共执行模块正在由其他任务修改,包括回执、工程统一保存、身份关联、资源隔离和 UI 状态。不得复制或清理这些未提交修改,也不得在其上混入本功能实现。 + +实施时使用独立开发分支 `codex/independent-verification` 和独立工作目录,按 `superpowers:using-git-worktrees` 流程准备。先核对已有分支是否存在并保留工作;不重置用户分支。基础纯逻辑和新增文件可基于已提交主线开发;接线前将其他任务的已合入修复同步进来,再复核接口。 + +| 接口边界 | 我们需要什么 | 处理原则 | +| --- | --- | --- | +| 工程身份 | 实例范围、生效位号、物理脚号及可靠对应证据 | 延用最新位号唯一关联规则;UID 为证据,不因UID缺失/变化一律拒绝 | +| 成功交接 | 真正已保存、关闭/重开回读的工程提交证明 | 待保存或只完成内存替换的项不得交接为成功 | +| 输入副本 | 本次 before、after、范围与摘要 | 缺失就登记无法校验,不能补造历史before | +| 预期变化 | 相对同一before的累计已成功修改及固定规则 | 不只传最后一条改动,不从after实际值反推预期 | +| 自有资源 | 当前本域CLI的归属和退出证明 | 复用既有接口,不修CAD退出;隔离桌面不被错误等同未退出CLI | +| UI公共文件 | 四导航插入点、关闭协作、主服务引用 | 窄范围接线,不覆盖其他任务实时刷新或状态投影改动 | + +接线不满足时仍可完成本域数据/规则测试;不得用虚构成功回执凑出可演示闭环。若同名类/方法已经被新版本增加,应先复用,不按旧文件清单重复建设。 + +## 2. 四个开发阶段 + +| 阶段 | 任务 | 完成后能做什么 | 阶段验收条件 | +| --- | --- | --- | --- | +| 第一阶段:校验任务与数据 | N01~N04 | 创建空任务、导入两份工程、接收成功项、保存版本和查询状态 | 重复/乱序不重复建项;新版本不覆盖旧输入;无来源限制;缺证据可见 | +| 第二阶段:独立校验与人工证据 | N05~N08 | 独立导出、逐项判断、警告分级,生成前后接线图所需数据 | 反脚检出;改名有警告;未知不通过;图和表能定位到原始证据 | +| 第三阶段:A 页面与完整操作 | N09~N11 | 第四页、任务选择、开始/停止/重校验、前后对照、报告和历史 | 有其他任务仍可新建;控制操作不换料;关闭重启安全;报告可独立复核 | +| 第四阶段:集成与交付验收 | N12 | 在实际应用包中完成两种输入路径和混合批次 | 相关/默认回归、真实只读输入、产物身份、正常关闭全部留证 | + +前三个阶段是内部可测交付,不等同发布版本。每阶段更新同一进度记录,注明实际完成的任务、提交、测试和能力缺口,不依据图片或测试数量推断已经支持的业务范围。 + +## 3. 十二个任务的工作量边界 + +| ID | 要实现的最小完整内容 | 依赖 | 做完怎么判断 | +| --- | --- | --- | --- | +| N01 | 输入、逐项检查、执行状态、结论和覆盖合同 | 无 | 空检查/缺必查不一致,错误优先,警告与未知分别保留 | +| N02 | SQLite校验任务、工程、不可变版本、尝试、运行与去重 | N01 | 同版同文幂等,同版异文拒绝,只有一个活动尝试,旧DB正常打开 | +| N03 | 独立导入、统一发布、成功交接和有界补交 | N02 | 一次批量和分次发布结果相同;只交接提交成功范围;创建不派发 | +| N04 | 当前版本投影、计数、分页、筛选、历史 | N03 | 24项计数正确,旧结果不重复,筛选不改变批量命令范围 | +| N05 | 复用原生导出的独立只读runner | N02、N03 | 不调用替换/CAD写入,工作副本隔离,资源忙只排队 | +| N06 | 器件/物理脚/连接/属性/名称的判断分级 | N01、N05 | 断线短接反脚、错属性均定位;允许改名给警告;缺证据未知 | +| N07 | 引脚Value、逻辑名、电气类型能力验证与适配 | N05、N06 | 证明字段来源与脚号对应;拿不到就unknown,不替代字段 | +| N08 | 同源issue、接线图数据、对照表和raw定位 | N06、N07 | 1/2脚前后位置固定,红线有对应事实,文字警告不画成接错线 | +| N09 | A页面、独立新建、四导航、工程表与检查器 | N04、N05、N08 | 与整体UI一致,已有任务时仍可新建,无来源/流水线横条 | +| N10 | 开始/停止/继续/重校验、关闭重启与版本竞争 | N05、N09 | 停止未派发项保留待校验,迟到结果不串版本,零重复换料 | +| N11 | 单项/整任务HTML/JSON、证据打开、历史和引用保留 | N08、N10 | 图表报告对应同一证据包,运行中报告标未完成,清历史不删证明 | +| N12 | 服务/Qt/真实只读输入/实际包验收 | N01~N11 | 全链路证据可复查,失败现场保留,支持范围写明 | + +顺序执行即可,不需要同时派多个代理。每项具体文件、接口签名、用例和7步清单在[N01~N12详细清单](2026-11-17-independent-verification-new-features.md)中;共84步,不在此重复创建另一套进度复选框。 + +## 4. 最早验证的两个能力点 + +N01~N04开发期间可以提前做N07的只读探针,尽早知道业务边界;只读探索结果不等于N07任务已完成。 + +| 能力点 | 成功时 | 无法取得时 | +| --- | --- | --- | +| 引脚级Value/名称/类型 | 保存准确字段、存在性、原始定位,与物理脚绑定后比较 | 明确标该字段未覆盖;用户必查时INCOMPLETE;不得用器件Value代替 | +| 库内引脚到焊盘映射 | 只有确切库版本和绑定证明才启用检查 | 首版显示未覆盖,不承诺能发现网表未体现的库内反脚 | + +已确认的工程接线反脚检查不能因为扩展映射拿不到就不做;也不能因为基础网表一致而宣称库内部映射通过。GND/VCC文字变化的语义字典和自动严重性仍沿用业务稿的保留决定,不在开发时临时让模型判断。 + +## 5. 开发时固定的接口载荷 + +这里固定形状,摘要、ID和受管路径由服务生成,示例是结构说明,不是可跳过验证的真实输入。 + +```python +input_record = { + 'item_key': 'stable-project-comparison-key', + 'project_key': 'stable-project-identity', + 'input_version': 1, + 'before_ref': {'manifest_id': 'before-id', 'sha256': 'a' * 64}, + 'after_ref': {'manifest_id': 'after-id', 'sha256': 'b' * 64}, + 'expectation_ref': None, + 'check_plan': { + 'policy_version': 'verification-v1', + 'required_checks': ['inputs', 'coverage', 'components', 'physical_pins', 'connections', 'net_names'], + 'optional_checks': ['pin_text'], + 'excluded_checks': ['footprint_mapping'], + }, +} +``` + +校验task_id与submission_id为外层命令参数;没有 source 字段。expectation_ref=None仅说明未核对换料规则;若后来提供规则,要发布新版本,不能修改原检查上下文。check_plan的id与N01实际定义保持一致,类型/枚举/摘要长度在边界拒绝非法值。 + +结果包至少分开保存:输入版本、attempt/generation、执行state、verdict、coverage、checks、issues、artifacts、resource_state。界面不得把attempt succeeded当成verdict CONSISTENT。 + +## 6. 每个提交的验证流程 + +1. 写本任务明确反例,运行该测试确认失败原因属于本功能缺失。 +2. 实现最小完整逻辑;同步所有调用方、必要fixture、序列化和导出。 +3. 运行该任务测试和与公共边界相关的既有回归,失败则定位根因,不通过跳过/放宽断言凑绿。 +4. 对照业务稿检查状态、图表数据、证据绑定和失败路径;确认未调用换料/恢复入口。 +5. 只提交本任务文件,记录提交SHA、实际命令、通过数量和未测范围,再进入下一项。 + +本仓库默认测试路径在 `pyproject.toml` 中为 `tests/v1_1` 与 `tests/ui`;只运行裸pytest不能声称DSH/打包组已测。N12需显式执行相关扩展组后,再跑默认suite。 + +```text +.venv/Scripts/python.exe -m pytest tests/v1_1/test_native_cli_netlist.py tests/v1_1/test_netlist_execution.py tests/v1_1/test_pr27_netlist_pause.py -q +.venv/Scripts/python.exe -m pytest tests/ui tests/dsh tests/packaging -q +.venv/Scripts/python.exe -m pytest -q +``` + +第一条是旧原生网表边界回归;第二条涵盖UI、DSH、打包;第三条按项目默认配置验证。具体新增测试文件由N01~N12逐项命令执行,不能只跑以上旧测试声称新功能完成。进程级测试使用新的短路径basetemp,环境变量仅对测试进程设置,不改系统用户环境。 + +## 7. 最终交付门槛 + +| 验收面 | 必须提供的证据 | +| --- | --- | +| 功能路径 | 已有换料成功数据交接与用户独立两份工程均可创建、运行、查看、重校验,且可共存 | +| 业务正确性 | 反脚/断线/短接/错属性/命名警告/缺证据均给出对应事实与范围 | +| 人工说服力 | 同一R12反脚在图、逐脚表、HTML报告、raw证据四处一致,能看出为什么异常 | +| 版本与幂等 | 重复接收零重复项;v1结果不覆盖v2;同版异文拒绝;旧attempt不能覆盖新结果 | +| 非阻塞与失败 | 单项问题保留后继续其他可运行项;资源/存储不确定时暂停正确范围,不假报通过 | +| 使用体验 | 980×700、1280×880和125%/150%可读;慢查询可导航和停止;新建按钮始终可用 | +| 生命周期 | 正常关闭、崩溃恢复、停止继续、证据丢失、历史清理均不损坏输入或重复换料 | +| 包与范围 | 实际包启动/入口/关闭、工具缺失原因、精确产物与输入摘要;未覆盖能力明确列出 | + +开发不设虚假的固定天数。每阶段通过验收出口后再推进;引脚字段/封装映射的探索结果影响能承诺的检查范围,不影响先交付可信基础校验和证据页面。 + +## 8. 交接状态 + +业务设计已获用户认可;本轮完善开发计划,不开始应用实现。按独立工作目录顺序执行,不创建新用户聊天,也不自动派发代理。推荐起点N01;公共接线N03/N05/N09等先核对其他任务已合入的最终接口。 + +详细任务均待实施。后续开发以本入口和[N01~N12清单](2026-11-17-independent-verification-new-features.md)共同为准,11月6日的V/U旧计划保留为历史参考,不能再并行照旧重建后端或来源界面。 diff --git a/docs/superpowers/specs/2026-11-17-independent-verification-business-design.md b/docs/superpowers/specs/2026-11-17-independent-verification-business-design.md new file mode 100644 index 0000000..532ff28 --- /dev/null +++ b/docs/superpowers/specs/2026-11-17-independent-verification-business-design.md @@ -0,0 +1,402 @@ +# 独立工程校验:判断、执行、状态与失败处理 + +日期:2026-11-17。状态:业务细化稿,尚未实现新增功能。本文落实本次对话已确定的校验任务与 A 界面;未回答的引脚语义问题明确列为待人工确认,不擅自变成自动放行规则。 + +## 1. 用户使用方式与本轮范围 + +用户可以随时创建校验任务,选择修改前、修改后的工程。前面的替换成功结果也可以自动交接到校验任务;校验页不展示或要求选择来源,不把当前换料任务作为新建校验的前置条件。 + +当前先在已有替换执行结果落盘后一次性交接。接收接口支持批量、增量、去重和版本更新,为后续实时交接留接口;本轮不改替换任务的实时刷新机制。 + +用户在工程表里先看结论,再点开同一物理脚号的前后连接图、差异表和原始证据,能够独立复核。校验不修改工程,不自动换脚、不重新换料;发现的问题集中记录。 + +本轮新增:校验任务与输入接收、独立只读运行与恢复、判断分级、引脚元数据能力探测、可复核证据、A 工作台和报告。其他任务正在处理的退出/收尾修复、任务列表修复、既有替换状态机和性能优化不纳入本轮。 + +## 2. 现有能力怎样复用 + +检查基线:`main/v1.3.1@b19afc6`。工作区有并行进行的 issue29 修改;实施前再次核对实际主线,不能覆盖其改动。 + +| 已有模块 | 直接复用 | 新增边界 | +| --- | --- | --- | +| `native_netlist.py` | 固定副本、HIER/effective ASCII/Keyin 导出、层级/实例/gate 与物理连接交叉核验 | 新增领域层调用已有公开捕获/导出接口;不重写原生导出器 | +| `netlist_verification.py` | 完整导出缓存、原生库回执绑定、原计划/实际成功证据 | 提取或暴露接收固定输入的薄适配;原有队列入口保持兼容 | +| `native_cli.OwnedCliScope` | 隐藏进程、归属和退出证明 | 独立校验只拥有自己的 CLI,不接管替换 CAD | +| `batch_resources.write_record` | 原子文件发布 | 新报告先完整发布再提交数据库引用 | +| `TaskStore`、schema、事务锁 | 持久化与升级 | 只新增校验表,不写 execution_operations 终态或重试预算 | +| `LatestQuery`、`ServiceWorker` | 异步读取、旧回调隔离 | UI 不同步跑导出或遍历全工程 | +| `HistoryRepository`、现有样式 | 事件与窗口视觉 | 四导航、任务列表、工程表和证据检查器 | + +现有比较器已能拒绝物理脚号/连接变化,并在已证明的目标符号替换中允许逻辑脚名变化;该变化目前没有警告。ASCII 引脚记录中的类型、引脚级 Value、库内焊盘映射不能因现有物理图通过而视为已覆盖。新增功能补充这些事实和范围,不全局放宽旧比较器。 + +## 3. 四种业务对象与身份 + +| 对象 | 是什么 | 身份与生命周期 | +| --- | --- | --- | +| 校验任务 task | 左侧一个名称,例如“电源板核对”;可以含多个工程 | 独立 task_id,随时新建;既有任务或排队不禁用新建 | +| 工程项 item | 中间表里的一行比较对象 | item_id;绑定 project_key、基线 before_id 和检查配置,不按名称猜测合并 | +| 输入版本 revision | 一对固定 before/after、预期变化及检查配置 | item_id + input_version;发布后不可修改 | +| 执行尝试 attempt | 对某个版本真正运行一次校验 | attempt_id + generation;重新校验增加尝试,不更改旧报告 | + +另有批量命令 run:只冻结本次选择的 item/revision 集合、派发顺序和停止意图,不建立第二套工程结论。任务的状态与统计由当前工程版本推导,不另造会与工程行矛盾的通过标记。 + +同名工程不自动合并。同一个工程更换了 before 基线,建立新的工程项;不能把另一轮 before 覆盖到原项上。相同基线下的新 after 与累计预期变化才是新 input_version。 + +## 4. 统一输入与未来增量交接 + +### 4.1 统一接收合同 + +UI、文件导入和成功交接最终调用同一个 `publish_inputs(task_id, inputs, submission_id)`。没有 source/type/mode 等按来路分流的字段。 + +| 字段 | 必需 | 含义与校验 | +| --- | --- | --- | +| task_id | 是 | 已存在的校验任务;创建独立任务不要求换料任务存在 | +| submission_id | 是 | 请求去重键;相同键与不同正文冲突时拒绝 | +| item_key / project_key | 是 | 发布者持久身份;独立导入由服务生成,不使用显示名作为身份 | +| input_version | 是 | 同工程项内递增整数;较旧版本不得夺回当前版本 | +| before_ref / after_ref | 是 | 受管快照引用及 manifest 摘要;缺失证据可登记不可用工程项,不能伪造输入 | +| expectation_ref | 可空 | 已确认的预期属性变化与适用器件、证据引用;空表示未提供换料规则,不等于确认所有属性都应不变 | +| check_plan | 是 | 本次要求核对的维度、必查/可选范围和固定策略版本 | +| payload_digest | 服务生成 | 规范化内容摘要,绑定输入、预期和检查计划 | + +内部证据仍保留真实执行回执、文件摘要和版本以供追溯,但它们不是 UI 的任务来源字段。不得以“没有换料任务”拒绝独立输入。 + +### 4.2 接收规则 + +1. task 不存在、外层结构不合法:整个请求拒绝,不修改任何任务。 +2. 外层有效后逐条处理;一条坏输入不会撤销其他条已接收的输入。返回 accepted、duplicates、stale_ignored、rejected 以及逐条原因。 +3. 相同 item_key/version/digest:幂等返回原记录,不加行、不重复排队。 +4. 相同 item_key/version、不同 digest:记输入冲突,不覆盖。 +5. 较旧版本:只返回旧记录或忽略,不成为当前版本。版本跳号允许,不能依据到达顺序推断修改顺序。 +6. 新版本:原子发布新 revision,然后移动 current_revision 指针;旧输入、运行和结果保留。 +7. 新工程/新版本默认待校验,接收本身不自动执行。正在运行的批量命令不自动吞入后来到达的项,避免未来持续流入导致命令永不结束。 +8. 当前一次性交接与未来逐条交接具有相同语义;未来是否自动开始是独立运行设置,首版默认手动。 + +### 4.3 成功交接与独立输入 + +- 成功交接从已落盘、已保存回读且归属准确的回执读取成功范围,引用已冻结前后副本;失败、不确定或未执行项不冒充成功工程。工程内部分成功时只能交接有完整检查范围和可靠 after 的成功集合,明确预期范围;不能宣称整个替换计划完成。 +- 若替换成功但附加校验副本缺失,仍登记该项并显示“缺少校验证据”,不撤销替换成功,也不从当前盘上补造旧 before。 +- 当前已有网表报告可以作为证据导入,但只有输入、工具、解析器、检查策略和输出摘要均匹配时才复用;不能用旧 verified 字段直接点亮新任务。 +- 独立新建填写任务名和前后工程;服务后台验证不同工程文件/数据库别名、源稳定性及可读性,冻结受管副本后发布同一种输入。没有预期清单时只比较结构和列出属性变化,不声称换料规则已符合。 +- 交接失败不影响已保存换料结果。接收去重和已有回执扫描允许重新交接;UI 不在结束回调里等待全部捕获或导出。首版进入校验页或重启时扫描有界、尚未交接的已完成结果,且不为缺失 before 创建替代基线。 + +## 5. 判断规则:先证明能检查,再判断结果 + +每个检查返回 `check_id`、`state`、`required`、`issues`、`evidence_refs`、`coverage_reason`。state 为 equal / expected_change / warning / error / unknown / not_requested。所有异常都有明确事实;警告不能抵消异常,未知不能冒充相同。 + +### 5.1 输入与范围 + +| 编号 | 判断内容 | 具体逻辑 | 结果 | +| --- | --- | --- | --- | +| J01 | 前后输入可信 | manifest 存在、摘要匹配、数据库和配置属于声明对象,源在捕获时稳定 | 缺失/损坏则 unknown,停止依赖该输入的检查 | +| J02 | 能完整读出 | HIER 实例集合、effective 器件/脚/网络互反覆盖与 Keyin 物理端点覆盖一致 | 部分/截断/不支持配置则 unknown,不能比较两个不完整图判通过 | +| J03 | 器件身份 | 延用最新实例范围+生效位号唯一对应;UID保留为证据,缺失、重复、变化不得否定已证明的位号对应 | 缺件、多件或位号改变为 error;真实位号/实例对应歧义为 unknown,不做相似匹配 | + +多 gate 使用工程实例范围+生效位号+物理脚作为对应依据,不能将同一位号的不同 gate 误报为重复器件;同一物理脚重叠仍为异常或无法完整核对。跨工程不合并身份。 + +### 5.2 脚号、连接和网名 + +| 编号 | 判断内容 | 具体逻辑 | 结果 | +| --- | --- | --- | --- | +| J04 | 物理脚号和集合 | 对应器件的物理脚号集合和占用次数必须相同,包括已知未连接脚 | 增减、重复或编号改变为 error;不能交换脚号消除差异 | +| J05 | 固定脚号的连接 | 每个端点 `(实例范围, 位号, 物理脚号)` 对应网络的完整端点集合前后相同 | 分组变化为 error;给出新增/丢失对端及网络分裂/合并 | +| J06 | 单连接端与未连接 | 有明确完整名册时区分“单端网络”“明确未连接”“导出未覆盖” | 已连接变未连接为 error,未覆盖为 unknown | +| J07 | 网名 | 连接分组相同后再比较名称 | 已识别自动生成名称变化保留说明;用户/未知网名变化保持 error,不能套用引脚文字警告 | + +R12.1 原连 NET_LOOP/U1.3、R12.2 原连 GND/C5.2,修改后两者互换:J05 必须报错。器件数、脚数、网络总数相同不能抵消此错误。 + +比较本质是端点分组,不能因为另一个脚仍写 GND 就推断整个器件接线正确;两个网络同名也不能替代端点集合证明。 + +### 5.3 预期属性与引脚文字 + +| 编号 | 判断内容 | 具体逻辑 | 结果 | +| --- | --- | --- | --- | +| J08 | 有清单的器件属性 | 只允许固定 expectation_ref 声明的目标 UID/位号及字段按精确目标变化;其余字段保持原值 | 已声明且符合为 expected_change;漏换/错值/非目标变化为 error | +| J09 | 没有预期清单 | 仍列出全部属性变化,区分器件 Value、引脚 Value 和网络名 | 属性变更为 warning,标“未核对换料规则”;不得显示规则符合。无变化也只证明一致,不证明某个换料目标已完成 | +| J10 | 引脚 Value/名称 | 先按固定物理脚号对应;保留原始文字,单独记录变化;不能把器件 Value 充当引脚 Value | 文字相同为 equal。用户确认的 loop→outloop 且结构/连接保持时为 warning;其他名称变化为 warning 并提示功能需确认,不自动宣称功能等价 | +| J11 | 功能位置疑点 | 若 GND/VCC 等文字变化或原两脚文字对调,保留原始值和结构证据 | 输出高关注 warning“疑似功能变化,需人工确认”;是否升级 error 尚未由用户确认。若 J04/J05 或可靠库映射已证明互换,直接 error,不依赖名称猜测 | +| J12 | 库内映射 | 已有可靠方法能读取并绑定确切库版本、symbol/Cell 和引脚→焊盘映射时再核对 | 明确反脚为 error;未实现/拿不到为 unknown 或 not_requested,显式显示未覆盖 | +| J13 | 原生身份表 | Keyin Part 表与 effective Part Number 各自保留 | 旧身份列与有效料号不一致单列 warning/限制说明,不改写原始输出,不据此推导 PCB 已验证 | + +J10 的“其他名称变化为 warning”只表示需要复核,不能解释为所有改名均安全。不能采用字符串相似度、模型猜测或全局 loop 替换来自动放行。引脚电气类型变更在可读取时与原值一起提示;其自动严重性字典首版不臆造。 + +预期值来自用户确认的清单、固定策略与可靠事务/库证据;不得从待校验 after 的实际字段倒推“预期就是这个值”。旧策略的特殊保留/NC 语义由已有函数解释并保留证据,本轮不另写一套换料策略。 + +### 5.4 首版检查范围 + +核心必查:可信输入、完整图、器件/位号、物理脚号、端点连接与名称;有 expectation_ref 时该范围内的预期属性也为必查。没有清单时属性检查为“只展示变化”,不能冒充目标检查。 + +引脚 Value/电气类型先做原生字段能力探测。探测未完成或字段缺失,报告明确 unknown;用户请求该项时不得算完整通过。库内部焊盘映射首版默认不请求,UI 固定披露“未覆盖:封装库内部映射”;有可靠适配器后才能启用为必查项。 + +检查计划记录 required_checks、optional_checks、excluded_checks 和策略摘要。未请求项不能被写成已检查;用户不能通过“一键忽略异常”改写原报告。只对当前输入和明确范围下结论。 + +## 6. 结论与执行状态必须分开 + +### 6.1 业务结论 + +```text +存在任何已证明 error → DIFFERENT(发现异常) +否则有必查 unknown → INCOMPLETE(无法完整校验) +否则有 warning → WARNING(检查完成,有警告) +否则全部必查 equal / expected_change → CONSISTENT(本次检查范围一致) +``` + +可选 unknown 使 coverage=partial 并显示未覆盖项;允许核心范围一致,但显示“核心检查一致,扩展项未覆盖”,不能笼统写全工程全部通过。必查 unknown 优先于警告,已经证明的异常优先于 unknown,两类事实都保留。 + +J08 未请求时,结论文字始终附“未核对换料规则”。人工作出“已查看/备注”的行为不改变机器结论;真正消除异常需要修改工程后发布新输入版本。 + +### 6.2 三组独立字段 + +| 字段 | 值 | 含义 | +| --- | --- | --- | +| input_state | receiving / ready / unavailable | 前后副本是否已可信发布 | +| attempt_state | queued / running / publishing / stopping / succeeded / failed / cancelled / interrupted | 校验程序是否完成执行;succeeded 可以对应 DIFFERENT | +| verdict | CONSISTENT / WARNING / DIFFERENT / INCOMPLETE / 空 | 工程内容结论;尚未得到结果时为空 | + +另存 resource_state=not_started/owned/released/unknown 与 currentness=current/historical。资源未知只影响归属的校验执行器准入,不改写已有换料回执,也不发出全局 CAD 退出命令。 + +## 7. 每个工程怎样执行 + +| 步骤 | 动作 | 发布物 / 下一步条件 | +| --- | --- | --- | +| E01 | 接收工程或导入两份文件 | 建 item 与不可变输入版本,登记缺证据原因 | +| E02 | 固定当前点击范围 | 全部待校验或明确所选 item/revision;提交后不跟随新版本漂移 | +| E03 | 入队与领取 | 事务内去重与 CAS;同一版本只允许一个活动尝试 | +| E04 | 复核固定输入 | 校验 manifest/摘要、工具与配置支持;原文件变化不偷偷换输入 | +| E05 | 准备工作副本 | 从受管冻结输入复制;原生工具不写原工程或冻结原件 | +| E06 | 导出前/后图和属性 | 复用已有 HIER/effective/Keyin;保存命令、版本、输出摘要和清理结果 | +| E07 | 核对覆盖 | 先执行 J01/J02;某维度缺数据就记录 unknown,不以空集合相同通过 | +| E08 | 执行判断 | J03~J13 只读取本版本输入和预期;检查之间按依赖分组继续,不因一个可定位差异跳过其他可检查维度 | +| E09 | 组织人工证据 | 生成逐脚差异、网络端点增删、前后示意和原始证据定位 | +| E10 | 确认资源退出 | 自有 CLI 收尾得到证明后才能提交执行完成并继续派发;不以“报告已写完”代替资源确认 | +| E11 | 发布结果 | 暂存→摘要与资源证明核对→原子发布产物→数据库 CAS 完成;迟到尝试不可覆盖新尝试 | +| E12 | 更新当前任务 | 更新工程行/计数;下一个工程继续,最后导出本命令汇总 | + +首版一个独立校验工程对处于运行中,新runner前后顺序导出,同时最多一个本域CLI;复用已有单次导出能力,不另建一个双线程批次池叠加并发。资源实际许可/系统准入继续生效,不能证明可并行时保留排队,不通过新建任务动作抢占替换资源。只增加任务和排队不占原工程写入租约;原有批次内部导出并发不由本功能改写。 + +发生差异不会立即弹模态框要求处理,不自动重新运行相同输入。只读工具异常首版由用户点击重校验;不借用、消耗或重置换料的一次自动重试额度。 + +## 8. 总流程图 + +```mermaid +flowchart TD + A[新建校验或接收已成功结果] --> B[统一接收接口与去重] + B --> C{固定前后输入可用} + C -->|否| D[登记无法校验及原因] + C -->|是| E[待校验] + E --> F[用户开始当前待校验或所选] + F --> G[冻结本次范围并入队] + G --> H[领取一个工程版本] + H --> I[复核输入并在工作副本导出] + I --> J{覆盖和格式可判断} + J -->|完整或部分可判断| K[逐项判断并保存未知范围] + J -->|无有效输入| L[记录执行失败或无法判断] + K --> M[生成前后对照与事实证据] + M --> O{自有资源已确认释放} + L --> O + D --> V[更新任务列表与原因] + O -->|是| N[原子发布结果并更新状态] + N --> P{本次范围还有待执行项} + P -->|有| H + P -->|无| V + O -->|否| Q[暂停该校验执行器并保留队列] + Q --> R[等待安全收尾或人工处理] + R -->|确认释放后用户继续| N +``` + +## 9. 状态图 + +### 9.1 单次执行尝试 + +```mermaid +stateDiagram-v2 + [*] --> Queued: 用户明确提交 + Queued --> Running: CAS领取且资源准入通过 + Queued --> Cancelled: 派发前取消 + Running --> Publishing: 证据与资源退出证明齐备 + Publishing --> Succeeded: 产物与数据库引用提交成功 + Running --> Failed: 工具或解析失败且资源已释放 + Publishing --> Failed: 结果发布失败且可确认落盘状态 + Running --> Stopping: 记录停止意图 + Publishing --> Stopping: 完成提交前请求停止 + Stopping --> Cancelled: 自有资源退出确认 + Queued --> Interrupted: 重启后冻结原队列 + Running --> Interrupted: 崩溃后核实旧进程退出 + Publishing --> Interrupted: 提交结果未能证明完整 + Stopping --> Interrupted: 重启后核实收尾状态 + Succeeded --> [*] + Failed --> [*] + Cancelled --> [*] + Interrupted --> [*] +``` + +Stopping 的 resource_state=unknown 时保持等待,不直接迁移 Cancelled。Succeeded 只表示比较处理完成,仍须读取 verdict;停止与发布竞争以数据库提交先后为准,完整终态已提交就保留真实结果,不改成“取消”。恢复/重校验建立新 attempt,旧终态不原地改回 running。 + +整run停止时,尚未实际派发的queued尝试记录cancelled及`run_stopped_before_dispatch`原因,释放队列预留;工程行恢复“待校验”,继续时创建新queued尝试。用户明确取消单个工程或已经启动的工程显示“已停止”;不能因两种行为都留下cancelled尝试就混淆行状态。 + +### 9.2 任务状态由工程当前版本推导 + +```mermaid +stateDiagram-v2 + [*] --> Empty: 创建任务 + Empty --> Ready: 收到可运行输入 + Empty --> Attention: 只有不可用输入 + Ready --> Active: 用户开始校验 + Active --> Stopping: 用户停止当前运行范围 + Stopping --> Paused: 归属资源已释放 + Paused --> Active: 用户继续尚未开始项 + Active --> Attention: 本次完成且有异常或缺证据 + Active --> Finished: 当前范围完成 + Attention --> Ready: 补充合法新输入或手动重校验 + Finished --> Ready: 收到新工程或新版本 + Paused --> Ready: 收到新输入且无活动派发 +``` + +队列尚未执行的行存在时,任务不得标“所有工程已完成”。任务可继续接收新输入;Finished 不是禁止接收的永久关闭状态。Attention 与 Finished 的详情仍显示准确计数,警告不导致自动重试。 + +## 10. 数据流向与版本更新 + +### 10.1 数据流图 + +```mermaid +flowchart LR + A[已落盘的成功结果] --> C[统一输入接收服务] + B[用户选择两份工程] --> D[稳定性检查与冻结副本] + D --> C + C --> S[(SQLite任务/工程/版本/尝试)] + C --> M[(受管快照及manifest)] + S --> Q[独立校验调度器] + Q --> M + M --> W[一次性工作副本] + W --> N[已有原生导出与覆盖核验] + N --> G[标准图与逐项判断] + E[(固定预期变化与策略版本)] --> G + G --> R[(不可变结果包和原始证据)] + R --> S + S --> U[A工作台查询投影] + R --> U + U --> H[人查看前后图/差异表/原始证据] + R --> X[导出HTML与JSON] +``` + +没有从校验服务回到替换执行器的写入箭头。GUI 不直接读原工程数据库,示意图与差异表来自同一个标准图和 issue 记录,不使用生图模型或语言模型生成工程判定。 + +### 10.2 新版本到来时 + +```mermaid +sequenceDiagram + participant P as 输入发布者 + participant S as 校验服务 + participant DB as 持久库 + participant W as 校验执行器 + participant UI as A工作台 + P->>S: 发布工程A v1和去重键 + S->>DB: 原子发布v1并设为当前 + S-->>P: 返回接收回执 + UI->>S: 开始工程A v1 + S->>DB: 建立queued尝试 + W->>DB: CAS领取v1 + P->>S: 发布工程A v2 + S->>DB: 新增v2并更新当前指针 + S-->>UI: v2待校验,v1正在处理历史版本 + W->>DB: 提交v1结果,绑定v1尝试 + DB-->>UI: v1结果归档,v2仍待校验 + P->>S: 重复v2或迟到v1 + S-->>P: 去重或忽略旧版,不新增派发 +``` + +同一 before 下,v2 的预期集合必须覆盖该 before 到 v2 after 的全部累计成功变化,不能只携带最后一条改动;否则其他合法变化会被误判。新一轮 before 不同则新建工程项。当前只做接收和版本管理,不在本轮实现替换侧实时推送。 + +## 11. 结果包:让人能够复核 + +每个 issue 必须有:稳定 issue_id、check_id、严重性、工程/版本、位号/实例、物理脚号、前值、后值、预期或保持规则、关联证据及定位、检查范围。没有足够定位时说明“图页未定位”,不编造图页或 CAD 截图。 + +| 产物 | 内容与约束 | +| --- | --- | +| `result.json` | 身份、attempt/generation、输入/工具/策略摘要、逐项结论、覆盖、问题与资源证明 | +| 标准图 | 物理脚、网络端点、有效属性、实例/多 gate、字段来源;原值不被正常化覆盖 | +| 原始导出 | HIER/effective/Keyin 和完整工具输出,保持原样 | +| 连接对照 | 前后相同脚号相同位置;只高亮变化连接,列新增/丢失对端 | +| 事实表 | 引脚/字段、替换前、替换后、判断、证据入口;与示意图共享同一 issue 数据 | +| 覆盖清单 | 已检查、未知、未请求;封装内部映射不能被工程网表结果隐含覆盖 | +| HTML/JSON报告 | 相同结果包渲染;明确任务、版本、生成时间和未完成项 | + +例如 R12 反脚:左右两张图均保持 1 脚在上、2 脚在下;前后网络/对端不同处标红。明确标“连接关系示意(由网表生成)”,不伪装原理图截图。命名警告用 amber,不能用红色导线假装发生实际断接。 + +UI 的原始证据入口只能打开受管、摘要匹配的文本/报告,不接受工程字符串或模型输出指定任意可执行路径。所有 HTML 字段转义,客户数据和原始网表不写入 Git。 + +## 12. 失败处理矩阵 + +| 编号 | 失败或变化 | 当前工程怎样处理 | 其他工程 / 后续 | +| --- | --- | --- | --- | +| F01 | 缺 before/after | input unavailable,指出缺哪个副本 | 继续其他可运行项;补合法记录,不补造 before | +| F02 | 独立导入源正在写入或复制中变化 | 不发布可信 revision,保留导入原因 | 可重新选择/捕获;其他任务可新建 | +| F03 | 相同版本不同内容 | 输入冲突,拒绝覆盖 | 返回逐条原因,其他已接收项保留 | +| F04 | 旧版本迟到/重复通知 | 幂等或 stale_ignored | 不再导出、不改当前结果 | +| F05 | 缺工具/不支持配置 | 明确能力原因,必查为 unknown | 其他支持项继续;不回退 CAD 读取 | +| F06 | CLI 超时/异常退出 | 保存诊断,自有进程安全收尾 | 确认 released 后继续下一项;用户可单项重校验 | +| F07 | CLI 无输出/空图/截断/覆盖不足 | 无法完整检查;保留可定位事实 | 不显示通过,其他工程继续 | +| F08 | 发现反脚/漏换/非目标改动 | succeeded + DIFFERENT,保存事实与证据 | 继续后续项,不自动修改或重试 | +| F09 | 只有符合条件的文字变化 | succeeded + WARNING | 继续,留待集中查看 | +| F10 | 引脚属性/库映射读取不支持 | 对应 check unknown/not_requested | 必查未知则 INCOMPLETE;未请求项始终披露 | +| F11 | 用户停止 | 先存停止意图,停止当前自有只读导出 | 未派发项回到待校验;当前 cancelled 后用户可重校验 | +| F12 | 自有资源退出不确定 | 保持 stopping + resource unknown | 暂停该校验执行器,不盲目开启下一导出,不杀用户 CAD | +| F13 | 应用关闭或崩溃 | 正常关闭先收尾;异常重启核实旧进程和产物 | interrupted 后等用户继续,不自动重复换料或开始校验 | +| F14 | 结果文件或数据库提交失败 | 不显示完成;旧结果保持 | 优先停止受影响发布/执行范围;存储故障不能保证后续落盘,不承诺其他项仍可持久化 | +| F15 | 保存文件后DB提交前崩溃 | 扫描已发布结果包并核对输入/attempt/token | 仅有完整不可变包、released证明且无更新尝试才可补提交;否则 interrupted | +| F16 | 迟到 worker 回调 | CAS拒绝当前终态覆盖,保留诊断 | 新尝试/新版本不受污染 | +| F17 | 当前工程文件后来变化 | 已固定版本仍能比较,其结果标“对应已保存副本” | 不偷偷替换 after;要核对新状态须新输入版本 | +| F18 | 报告丢失/摘要不符 | UI显示证据不可用,保留原记录 | 可对原固定输入重校验;不能用残留绿灯代替证据 | + +一般异常不弹阻塞对话框。需要用户选择路径、确认停止或操作外部文件时才交互。资源/存储归属异常属于无法安全继续的边界,不用“非阻塞”掩盖它。 + +```mermaid +flowchart TD + A[步骤异常或用户停止] --> B{已有完整提交的终态} + B -->|有| C[保留真实结论与证据] + B -->|无| D[记录失败或停止意图] + D --> E[收尾本次自有只读进程] + E --> F{资源退出是否有证明} + F -->|有且存储可用| G[当前项终态,其他待执行项继续] + F -->|无| H[保持停止中,暂停该执行器] + H --> I[继续收尾或人工处理资源] + I -->|确认退出后用户继续| G + D -->|持久化不可用| J[显示存储故障,暂停结果发布] +``` + +## 13. A 工作台与数量口径 + +- 四导航保持一致;上方只有“工程校验”和始终可用的“新建校验”。无来源、流水线或返回替换任务横条。 +- 左侧先选择校验任务,再筛选当前任务工程;中间表与右侧证据随同一个 item/revision 切换。 +- 新建任务只需名称;选择两份工程可在新建对话框完成,也可先建空任务后加工程。校验侧不要求用户先创建替换任务。 +- “开始待校验”仅对当前任务所有 ready、未提交的当前版本生效,不受表格筛选暗中缩小范围;“校验所选”只对显式勾选版本生效。勾选随切任务/分页/筛选清空并提示,避免隐藏提交。 +- “重新校验此工程”默认当前选中版本;历史版本只能从历史详情显式重校验并始终标历史,不能把其结果挂到当前版本。 +- 表格每页100项,差异每页100项;250ms搜索防抖,后台查询代次隔离旧回调;不在GUI扫描全部网表。 +- 统计只取每个 item 的 current_revision。已处理 = 一致 + 有警告 + 有异常 + 无法完整校验;排队/执行中/待校验/已停止/中断分别列出。失败且无有效业务结果计入无法校验,并保留“执行失败”原因,不计一致。 +- 旧版结果和旧尝试不重复计入当前计数。重校验排队后该行显示排队中,旧结果可展开查看但不继续充当当前已处理结论。 +- 没有完整证据的“处理结束”不显示绿色通过;只有 scoped 一致可使用绿色,并带检查范围。 + +## 14. 持久化、接口与发布顺序 + +新增校验 task/item/input_revision/attempt/run 与命令去重记录,复用当前 SQLite 事务和日志模式。文件内容保存在受管目录,数据库存身份、状态、摘要与引用;不在新表复制原 execution_operations 状态。运行去重/停止命令可使用校验域自己的 request 表;不复用专用于 AI 创建任务的请求语义。 + +```text +verification///inputs//manifest.json +verification///attempts//raw/... +verification///attempts//result.json +verification///attempts//report.html +``` + +输入版本、尝试、产物路径均由服务生成并验证归属,不允许外部命令在受管目录之外指定输出位置。清历史不删除校验结果;活动/当前引用的快照、原生证明和结果包不得按普通日志保留期清掉。首版不新增“一键删除证据”入口。 + +发布顺序固定:完整暂存文件 → 原子发布 manifest/结果包 → DB事务验证身份与generation并引用 → 通知UI。目录与DB不能跨资源真原子,使用上述顺序和 F15 恢复规则;拒绝“先更新成功状态,再尝试写报告”。 + +## 15. 能力门禁和未确认事项 + +1. 引脚级 Value 的实际字段、端点逻辑名与物理脚号对应、可读电气类型需用真实导出确认;缺失不以器件属性替代。 +2. 库内脚→焊盘读取尚未证明,首版可先交付工程物理连接校验与明确未覆盖项,不宣称封装制造验证。 +3. GND→VCC 或纯功能文字对调的自动严重性尚未由用户确认,首版保留高关注警告,不让模型推断电气等价或改工程。 +4. 用户网名变化暂不放宽为普通命名警告;后续若要放宽,独立规则与反例确认。 +5. 多层级/多 gate 当前已有读取能力;直接换料的子实例范围不是本轮新增任务。独立比较若不能唯一建立前后对应,返回 unknown,不强行比对。 +6. 旧 before 缺失不会因为新增页面而变得可恢复;真实新副本验收与图像原型分开。 + +实施从[开发与交付入口](../plans/2026-11-17-verification-development.md)进入,逐项步骤见[独立校验新增功能计划](../plans/2026-11-17-independent-verification-new-features.md)。本文及计划不授权开始 CAD 写入、改动其他任务的修复或发布程序。 -- 2.39.5 From 0406028a02b52a4f6c896035f074369d3ce4ce6b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=98=BF=E7=99=BD=E5=8F=94?= <11794527+absfan@user.noreply.gitee.com> Date: Tue, 17 Nov 2026 15:19:38 +0800 Subject: [PATCH 02/27] feat: define independent verification contracts and verdicts --- .../verification/__init__.py | 1 + .../verification/contracts.py | 109 ++++++++++++++++++ ...test_independent_verification_contracts.py | 79 +++++++++++++ 3 files changed, 189 insertions(+) create mode 100644 src/dx_productivity/trial_task_center/verification/__init__.py create mode 100644 src/dx_productivity/trial_task_center/verification/contracts.py create mode 100644 tests/v1_1/test_independent_verification_contracts.py diff --git a/src/dx_productivity/trial_task_center/verification/__init__.py b/src/dx_productivity/trial_task_center/verification/__init__.py new file mode 100644 index 0000000..00c27f8 --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/__init__.py @@ -0,0 +1 @@ +"""Independent, read-only project verification and traceable evidence.""" diff --git a/src/dx_productivity/trial_task_center/verification/contracts.py b/src/dx_productivity/trial_task_center/verification/contracts.py new file mode 100644 index 0000000..8064075 --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/contracts.py @@ -0,0 +1,109 @@ +"""Versioned input contracts and conclusions independent of execution status.""" +import copy +import hashlib +import json +import re + +from ..errors import TaskCenterError + +CHECKS = frozenset(('inputs','coverage','components','physical_pins','connections','net_names', + 'declared_attributes','attribute_changes','pin_text','pin_semantics','footprint_mapping','export_identity')) +STATES = frozenset(('equal','expected_change','warning','error','unknown','not_requested')) +ACTIVE = ('queued','running','publishing','stopping') +TERMINAL = ('succeeded','failed','cancelled','interrupted') + + +def fail(message, code='verification_input'): + raise TaskCenterError(code, message) + + +def digest(value): + return hashlib.sha256(json.dumps(value, sort_keys=True, ensure_ascii=False, + separators=(',', ':'), allow_nan=False).encode('utf-8')).hexdigest() + + +def identifier(value): + if not isinstance(value, str) or not value.strip() or len(value) > 256 or any(ord(c) < 32 for c in value): + fail('标识不能为空或包含控制字符。') + return value + + +def artifact_ref(value): + if value is None: + return None + if (not isinstance(value, dict) or set(value) != {'manifest_id','sha256'} + or re.fullmatch('[0-9a-f]{32}', str(value['manifest_id'])) is None + or re.fullmatch('[0-9a-f]{64}', str(value['sha256'])) is None): + fail('校验证据引用无效。') + return dict(value) + + +def default_plan(): + return {'policy_version': 'verification-v1', + 'required_checks': ['inputs','coverage','components','physical_pins','connections','net_names'], + 'optional_checks': ['attribute_changes','pin_text','pin_semantics','export_identity'], + 'excluded_checks': ['footprint_mapping']} + + +def validate_plan(plan): + if not isinstance(plan, dict) or set(plan) != {'policy_version','required_checks','optional_checks','excluded_checks'}: + fail('检查计划字段不完整。') + if plan['policy_version'] != 'verification-v1': + fail('不支持的校验策略版本。') + groups = [plan[key] for key in ('required_checks','optional_checks','excluded_checks')] + if any(not isinstance(group, (list,tuple)) for group in groups): + fail('检查范围必须为列表。') + flat = [key for group in groups for key in group] + if not groups[0] or any(not isinstance(key,str) or key not in CHECKS for key in flat) or len(set(flat)) != len(flat): + fail('检查范围为空、重复或包含未知项目。') + return copy.deepcopy(plan) + + +def validate_input(value): + allowed = {'item_key','project_key','input_version','before_ref','after_ref','expectation_ref', + 'check_plan','display_name','unavailable_reason'} + required = {'item_key','project_key','input_version','before_ref','after_ref','expectation_ref','check_plan'} + if not isinstance(value,dict) or set(value) - allowed or not required <= set(value): + fail('校验输入字段不完整或包含不支持字段。') + result = copy.deepcopy(value) + for key in ('item_key','project_key'): + identifier(result[key]) + if type(result['input_version']) is not int or not 1 <= result['input_version'] <= 2**31-1: + fail('输入版本必须为正整数。') + for key in ('before_ref','after_ref','expectation_ref'): + result[key] = artifact_ref(result[key]) + result['check_plan'] = validate_plan(result['check_plan']) + result['display_name'] = identifier(result.get('display_name') or result['project_key']) + reason = result.get('unavailable_reason','') + if not isinstance(reason,str) or len(reason)>4000: + fail('不可用原因无效。') + if not result['before_ref'] or not result['after_ref']: + reason = reason or '缺少替换前或替换后的可信副本。' + result.update(input_state='unavailable' if reason else 'ready', unavailable_reason=reason) + result['payload_digest'] = digest(result) + return result + + +def rollup_results(checks, *, required_checks, optional_checks=()): + if not required_checks or any(key not in CHECKS for key in (*required_checks,*optional_checks)): + fail('必查项目不能为空。', 'verification_check_plan') + states = {} + for row in checks: + key, state = row.get('check_id'), row.get('state') + if key not in CHECKS or state not in STATES or key in states: + fail('检查结果包含重复或未知项目。', 'verification_result') + states[key] = state + requested = tuple(dict.fromkeys((*required_checks,*optional_checks))) + unknown = [key for key in requested if states.get(key, 'unknown') in {'unknown','not_requested'}] + if any(state=='error' for state in states.values()): + verdict = 'DIFFERENT' + elif any(states.get(key,'unknown') in {'unknown','not_requested'} for key in required_checks): + verdict = 'INCOMPLETE' + elif any(state=='warning' for state in states.values()): + verdict = 'WARNING' + else: + verdict = 'CONSISTENT' + return {'verdict': verdict, 'coverage': 'partial' if unknown else 'complete', + 'unknown_checks': unknown, 'checked': [key for key in requested if key not in unknown], + 'warnings': sum(state=='warning' for state in states.values()), + 'errors': sum(state=='error' for state in states.values())} diff --git a/tests/v1_1/test_independent_verification_contracts.py b/tests/v1_1/test_independent_verification_contracts.py new file mode 100644 index 0000000..8df737d --- /dev/null +++ b/tests/v1_1/test_independent_verification_contracts.py @@ -0,0 +1,79 @@ +import copy +import pytest + +from dx_productivity.trial_task_center.errors import TaskCenterError + + +def payload(): + return {'item_key': 'board', 'project_key': 'board', 'input_version': 1, + 'before_ref': {'manifest_id': 'a' * 32, 'sha256': '1' * 64}, + 'after_ref': {'manifest_id': 'b' * 32, 'sha256': '2' * 64}, + 'expectation_ref': None, + 'check_plan': {'policy_version': 'verification-v1', 'required_checks': ['connections'], + 'optional_checks': ['pin_text'], 'excluded_checks': ['footprint_mapping']}} + + +@pytest.mark.parametrize('state,want', [('equal','CONSISTENT'), ('warning','WARNING'), + ('error','DIFFERENT'), ('unknown','INCOMPLETE'), + ('not_requested','INCOMPLETE')]) +def test_required_checks_determine_verdict_without_hiding_missing_checks(state, want): + from dx_productivity.trial_task_center.verification.contracts import rollup_results + result = rollup_results(({'check_id': 'connections', 'state': state, 'issues': []},), + required_checks=('connections',)) + assert result['verdict'] == want + + +def test_error_wins_but_unknown_coverage_remains_visible(): + from dx_productivity.trial_task_center.verification.contracts import rollup_results + result = rollup_results(({'check_id':'connections','state':'error','issues':[]},), + required_checks=('connections','physical_pins')) + assert result['verdict'] == 'DIFFERENT' + assert result['coverage'] == 'partial' + assert result['unknown_checks'] == ['physical_pins'] + + +def test_empty_or_duplicate_checks_cannot_be_consistency(): + from dx_productivity.trial_task_center.verification.contracts import rollup_results + assert rollup_results((), required_checks=('connections',))['verdict'] == 'INCOMPLETE' + with pytest.raises(TaskCenterError): + rollup_results((), required_checks=()) + row = {'check_id':'connections','state':'equal','issues':[]} + with pytest.raises(TaskCenterError): + rollup_results((row,row), required_checks=('connections',)) + + +def test_optional_unknown_is_explicit_without_erasing_core_result(): + from dx_productivity.trial_task_center.verification.contracts import rollup_results + result = rollup_results(({'check_id':'connections','state':'equal','issues':[]},), + required_checks=('connections',), optional_checks=('pin_text',)) + assert result['verdict'] == 'CONSISTENT' + assert result['coverage'] == 'partial' + assert result['unknown_checks'] == ['pin_text'] + + +def test_input_is_detached_and_cannot_contain_source_or_arbitrary_paths(): + from dx_productivity.trial_task_center.verification.contracts import validate_input + value = payload() + result = validate_input(value) + value['check_plan']['required_checks'].clear() + assert result['check_plan']['required_checks'] == ['connections'] + for name in ('source','output_path'): + bad = payload(); bad[name] = 'anything' + with pytest.raises(TaskCenterError): validate_input(bad) + + +@pytest.mark.parametrize('field,value', [('input_version', True), ('input_version',0), + ('before_ref', {'manifest_id':'../outside','sha256':'1'*64}), + ('after_ref', {'manifest_id':'b'*32,'sha256':'invalid'})]) +def test_invalid_input_never_enters_storage(field,value): + from dx_productivity.trial_task_center.verification.contracts import validate_input + bad = payload(); bad[field] = value + with pytest.raises(TaskCenterError): validate_input(bad) + + +def test_missing_capture_stays_recordable_as_unavailable(): + from dx_productivity.trial_task_center.verification.contracts import validate_input + value = payload(); value['before_ref'] = None + result = validate_input(value) + assert result['input_state'] == 'unavailable' + assert result['unavailable_reason'] -- 2.39.5 From f5d39f6261443ab2eef40c3a99eee12baae643aa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=98=BF=E7=99=BD=E5=8F=94?= <11794527+absfan@user.noreply.gitee.com> Date: Tue, 17 Nov 2026 15:22:10 +0800 Subject: [PATCH 03/27] feat: persist verification tasks inputs and attempts --- .../trial_task_center/store_schema.py | 2 + .../trial_task_center/verification/store.py | 185 ++++++++++++++++++ .../test_independent_verification_store.py | 83 ++++++++ 3 files changed, 270 insertions(+) create mode 100644 src/dx_productivity/trial_task_center/verification/store.py create mode 100644 tests/v1_1/test_independent_verification_store.py diff --git a/src/dx_productivity/trial_task_center/store_schema.py b/src/dx_productivity/trial_task_center/store_schema.py index 02a1ab9..3457ca3 100644 --- a/src/dx_productivity/trial_task_center/store_schema.py +++ b/src/dx_productivity/trial_task_center/store_schema.py @@ -65,6 +65,8 @@ class StoreSchema: from .execution_journal import create_execution_schema create_history_schema(self._store._connection) create_execution_schema(self._store._connection) + from .verification.store import create_schema as create_verification_schema + create_verification_schema(self._store._connection) def _create_schema_v1(self) -> None: statements = ( diff --git a/src/dx_productivity/trial_task_center/verification/store.py b/src/dx_productivity/trial_task_center/verification/store.py new file mode 100644 index 0000000..6572b11 --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/store.py @@ -0,0 +1,185 @@ +"""Transactional verification records; replacement receipts are never modified.""" +from datetime import datetime, timezone +import json +from uuid import uuid4 + +from .contracts import ACTIVE, TERMINAL, digest, fail, identifier, validate_input +from ..errors import TaskCenterError + + +def now(): + return datetime.now(timezone.utc).isoformat() + + +def encode(value): + return json.dumps(value, ensure_ascii=False, sort_keys=True, allow_nan=False) + + +def create_schema(c): + statements = ( + '''CREATE TABLE IF NOT EXISTS verification_tasks ( + task_id TEXT PRIMARY KEY, name TEXT NOT NULL, created TEXT NOT NULL, + view_revision INTEGER NOT NULL DEFAULT 0)''', + '''CREATE TABLE IF NOT EXISTS verification_items ( + item_id TEXT PRIMARY KEY, task_id TEXT NOT NULL REFERENCES verification_tasks(task_id), + item_key TEXT NOT NULL, project_key TEXT NOT NULL, before_id TEXT, + display_name TEXT NOT NULL, current_version INTEGER NOT NULL, + UNIQUE(task_id,item_key))''', + '''CREATE TABLE IF NOT EXISTS verification_input_revisions ( + item_id TEXT NOT NULL REFERENCES verification_items(item_id), input_version INTEGER NOT NULL, + payload_json TEXT NOT NULL, payload_digest TEXT NOT NULL, created TEXT NOT NULL, + PRIMARY KEY(item_id,input_version))''', + '''CREATE TABLE IF NOT EXISTS verification_attempts ( + attempt_id TEXT PRIMARY KEY, item_id TEXT NOT NULL, input_version INTEGER NOT NULL, + generation INTEGER NOT NULL, state TEXT NOT NULL, owner_id TEXT, run_id TEXT, + result_json TEXT, reason TEXT NOT NULL DEFAULT '', resource_state TEXT NOT NULL DEFAULT 'not_started', + created TEXT NOT NULL, updated TEXT NOT NULL, + FOREIGN KEY(item_id,input_version) REFERENCES verification_input_revisions(item_id,input_version))''', + '''CREATE UNIQUE INDEX IF NOT EXISTS verification_active_attempt ON verification_attempts(item_id,input_version) + WHERE state IN ('queued','running','publishing','stopping')''', + '''CREATE TABLE IF NOT EXISTS verification_runs ( + run_id TEXT PRIMARY KEY, task_id TEXT NOT NULL REFERENCES verification_tasks(task_id), + members_json TEXT NOT NULL, stop_requested INTEGER NOT NULL DEFAULT 0, + state TEXT NOT NULL DEFAULT 'queued', created TEXT NOT NULL)''', + '''CREATE TABLE IF NOT EXISTS verification_requests ( + kind TEXT NOT NULL, request_id TEXT NOT NULL, request_hash TEXT NOT NULL, result_json TEXT NOT NULL, + PRIMARY KEY(kind,request_id))''', + ) + for statement in statements: c.execute(statement) + + +class VerificationRepository: + def __init__(self, task_store): + self.store = task_store + with task_store.transaction(): create_schema(task_store._connection) + + @property + def connection(self): return self.store._connection + + def _request(self, kind, request_id, body): + identifier(request_id) + row = self.connection.execute('SELECT * FROM verification_requests WHERE kind=? AND request_id=?', + (kind,request_id)).fetchone() + if row: + if row['request_hash'] != digest(body): fail('相同请求标识对应不同内容。','verification_conflict') + return json.loads(row['result_json']) + + def _remember(self, kind, request_id, body, result): + self.connection.execute('INSERT INTO verification_requests VALUES (?,?,?,?)', + (kind,request_id,digest(body),encode(result))) + return result + + def _touch(self, task_id): + self.connection.execute('UPDATE verification_tasks SET view_revision=view_revision+1 WHERE task_id=?',(task_id,)) + + def _one(self, table, key, value): + with self.store._lock: + row = self.connection.execute(f'SELECT * FROM {table} WHERE {key}=?',(value,)).fetchone() + if row is None: fail('找不到校验记录。','verification_not_found') + return dict(row) + + def task(self, task_id): return self._one('verification_tasks','task_id',task_id) + def item(self, item_id): return self._one('verification_items','item_id',item_id) + + def revision(self, item_id, version): + with self.store._lock: + row = self.connection.execute('SELECT * FROM verification_input_revisions WHERE item_id=? AND input_version=?', + (item_id,version)).fetchone() + if row is None: fail('输入版本不存在。','verification_not_found') + return dict(row) | {'payload':json.loads(row['payload_json'])} + + def attempt(self, attempt_id): + row = self._one('verification_attempts','attempt_id',attempt_id) + row['result'] = json.loads(row['result_json']) if row['result_json'] else None + return row + + def latest_attempt(self, item_id, version): + with self.store._lock: + row = self.connection.execute('SELECT attempt_id FROM verification_attempts WHERE item_id=? AND input_version=? ORDER BY generation DESC LIMIT 1', + (item_id,version)).fetchone() + return self.attempt(row[0]) if row else None + + def create_task(self, name, *, request_id): + name = identifier(name).strip() + with self.store.transaction(): + old = self._request('create',request_id,name) + if old is not None: return old + task_id = uuid4().hex + self.connection.execute('INSERT INTO verification_tasks(task_id,name,created) VALUES (?,?,?)',(task_id,name,now())) + return self._remember('create',request_id,name,self.task(task_id)) + + def publish(self, task_id, inputs, *, submission_id): + body = {'task_id':task_id,'inputs':inputs} + with self.store.transaction(): + self.task(task_id) + old = self._request('publish',submission_id,body) + if old is not None: return old + result = {key:[] for key in ('accepted','duplicates','stale_ignored','rejected')} + for index,value in enumerate(inputs): + try: + row = validate_input(value) + item = self.connection.execute('SELECT * FROM verification_items WHERE task_id=? AND item_key=?', + (task_id,row['item_key'])).fetchone() + before_id = row['before_ref']['manifest_id'] if row['before_ref'] else None + if item: + if item['project_key'] != row['project_key'] or (item['before_id'] and item['before_id'] != before_id): + fail('工程身份或原始基线变化,请新增比较项。','verification_conflict') + item_id = item['item_id'] + existing = self.connection.execute('SELECT payload_digest FROM verification_input_revisions WHERE item_id=? AND input_version=?', + (item_id,row['input_version'])).fetchone() + ref = {'item_id':item_id,'input_version':row['input_version']} + if existing: + if existing[0] != row['payload_digest']: fail('同一版本内容冲突。','verification_conflict') + result['duplicates'].append(ref); continue + if row['input_version'] < item['current_version']: + result['stale_ignored'].append(ref); continue + else: + item_id = uuid4().hex + self.connection.execute('INSERT INTO verification_items VALUES (?,?,?,?,?,?,?)', + (item_id,task_id,row['item_key'],row['project_key'],before_id,row['display_name'],row['input_version'])) + self.connection.execute('INSERT INTO verification_input_revisions VALUES (?,?,?,?,?)', + (item_id,row['input_version'],encode(row),row['payload_digest'],now())) + self.connection.execute('UPDATE verification_items SET current_version=?,before_id=COALESCE(before_id,?),display_name=? WHERE item_id=?', + (row['input_version'],before_id,row['display_name'],item_id)) + result['accepted'].append({'item_id':item_id,'input_version':row['input_version']}) + self._touch(task_id) + except TaskCenterError as error: + result['rejected'].append({'index':index,'code':error.code,'reason':error.message}) + return self._remember('publish',submission_id,body,result) + + def create_attempt(self, item_id, version, *, request_id, run_id=None): + body = [item_id,version] + with self.store.transaction(): + old = self._request('attempt',request_id,body) + if old is not None: return old + item = self.item(item_id) + revision = self.revision(item_id,version) + if revision['payload']['input_state'] != 'ready': fail('前后输入不可用。') + current = self.latest_attempt(item_id,version) + if current and current['state'] in ACTIVE: + return self._remember('attempt',request_id,body,current) + generation = (current['generation'] + 1) if current else 1 + attempt_id, stamp = uuid4().hex, now() + self.connection.execute('''INSERT INTO verification_attempts + (attempt_id,item_id,input_version,generation,state,run_id,created,updated) + VALUES (?,?,?,?,'queued',?,?,?)''',(attempt_id,item_id,version,generation,run_id,stamp,stamp)) + self._touch(item['task_id']) + return self._remember('attempt',request_id,body,self.attempt(attempt_id)) + + def claim(self, attempt_id, *, owner_id): + with self.store.transaction(): + changed = self.connection.execute("UPDATE verification_attempts SET state='running',owner_id=?,updated=? WHERE attempt_id=? AND state='queued'", + (identifier(owner_id),now(),attempt_id)).rowcount + return self.attempt(attempt_id) if changed else None + + def finish(self, attempt_id, *, generation, result): + with self.store.transaction(): + attempt = self.attempt(attempt_id) + if attempt['generation'] != generation or attempt['state'] not in {'running','publishing'}: return False + if result.get('resource_state') != 'released': fail('资源退出尚未确认。','verification_resources') + state = result.get('attempt_state','succeeded') + if state not in TERMINAL: fail('无效校验终态。') + self.connection.execute('UPDATE verification_attempts SET state=?,result_json=?,resource_state=?,updated=? WHERE attempt_id=?', + (state,encode(result),'released',now(),attempt_id)) + self._touch(self.item(attempt['item_id'])['task_id']) + return True diff --git a/tests/v1_1/test_independent_verification_store.py b/tests/v1_1/test_independent_verification_store.py new file mode 100644 index 0000000..b0e66cd --- /dev/null +++ b/tests/v1_1/test_independent_verification_store.py @@ -0,0 +1,83 @@ +import pytest +from dx_productivity.trial_task_center.store import TaskStore +from dx_productivity.trial_task_center.errors import TaskCenterError +from test_independent_verification_contracts import payload + + +@pytest.fixture +def repo(tmp_path): + from dx_productivity.trial_task_center.verification.store import VerificationRepository + store = TaskStore(tmp_path/'tasks.db') + try: yield VerificationRepository(store) + finally: store.close() + + +def test_tasks_are_independent_and_create_is_idempotent(repo): + task = repo.create_task('校验', request_id='one') + assert repo.create_task('校验',request_id='one') == task + assert repo.create_task('校验',request_id='two')['task_id'] != task['task_id'] + with pytest.raises(TaskCenterError): repo.create_task('changed',request_id='one') + assert repo.store.list_tasks() == () + + +def test_versions_are_immutable_and_delivery_is_idempotent(repo): + task = repo.create_task('校验',request_id='a')['task_id'] + first = repo.publish(task,(payload(),),submission_id='s1') + item = first['accepted'][0]['item_id'] + assert repo.publish(task,(payload(),),submission_id='s1') == first + assert len(repo.publish(task,(payload(),),submission_id='s2')['duplicates']) == 1 + newer = payload(); newer['input_version'] = 3; newer['after_ref']['sha256'] = '3'*64 + repo.publish(task,(newer,),submission_id='s3') + older = payload(); older['input_version'] = 2 + assert repo.publish(task,(older,),submission_id='s4')['stale_ignored'] + assert repo.item(item)['current_version'] == 3 + bad = payload(); bad['after_ref']['sha256'] = '5'*64 + assert repo.publish(task,(bad,),submission_id='s5')['rejected'] + assert repo.revision(item,1)['payload']['after_ref']['sha256'] == '2'*64 + + +def test_bad_item_does_not_erase_other_input_and_bad_task_does_not_publish(repo): + task = repo.create_task('校验',request_id='a')['task_id'] + bad = payload(); bad['input_version'] = -1 + result = repo.publish(task,(bad,payload()),submission_id='mixed') + assert len(result['accepted']) == len(result['rejected']) == 1 + with pytest.raises(TaskCenterError): repo.publish('missing',(payload(),),submission_id='x') + + +def test_single_active_attempt_and_late_result_cannot_override_new_attempt(repo): + task = repo.create_task('校验',request_id='a')['task_id'] + item = repo.publish(task,(payload(),),submission_id='s')['accepted'][0]['item_id'] + first = repo.create_attempt(item,1,request_id='run-1') + assert repo.create_attempt(item,1,request_id='run-2')['attempt_id'] == first['attempt_id'] + claimed = repo.claim(first['attempt_id'],owner_id='owner') + assert repo.claim(first['attempt_id'],owner_id='other') is None + assert not repo.finish(first['attempt_id'],generation=99,result={'resource_state':'released'}) + assert repo.finish(first['attempt_id'],generation=claimed['generation'], + result={'resource_state':'released','verdict':'DIFFERENT'}) + second = repo.create_attempt(item,1,request_id='run-3') + assert second['generation'] > first['generation'] + assert not repo.finish(first['attempt_id'],generation=first['generation'],result={'resource_state':'released'}) + assert repo.attempt(second['attempt_id'])['state'] == 'queued' + + +def test_old_input_attempt_completion_does_not_move_current_revision(repo): + task = repo.create_task('校验',request_id='a')['task_id'] + item = repo.publish(task,(payload(),),submission_id='s')['accepted'][0]['item_id'] + attempt = repo.create_attempt(item,1,request_id='run'); repo.claim(attempt['attempt_id'],owner_id='owner') + newer = payload(); newer['input_version'] = 2 + repo.publish(task,(newer,),submission_id='s2') + assert repo.finish(attempt['attempt_id'],generation=attempt['generation'],result={'resource_state':'released','verdict':'CONSISTENT'}) + assert repo.item(item)['current_version'] == 2 + assert repo.latest_attempt(item,2) is None + + +def test_schema_survives_reopen_and_does_not_change_execution_tables(tmp_path): + from dx_productivity.trial_task_center.verification.store import VerificationRepository + path = tmp_path/'tasks.db' + store = TaskStore(path); repo = VerificationRepository(store) + task = repo.create_task('持久任务',request_id='p') + store.close(); store = TaskStore(path) + try: + assert VerificationRepository(store).task(task['task_id'])['name'] == '持久任务' + assert store._connection.execute('SELECT COUNT(*) FROM execution_operations').fetchone()[0] == 0 + finally: store.close() -- 2.39.5 From 76074f8d110f183d16a116da85dcb81f4ec28061 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=98=BF=E7=99=BD=E5=8F=94?= <11794527+absfan@user.noreply.gitee.com> Date: Tue, 17 Nov 2026 15:36:17 +0800 Subject: [PATCH 04/27] feat: receive verification inputs and import project pairs --- src/dx_productivity/dsh/execution_runs.py | 9 ++ .../trial_task_center/service.py | 7 + .../trial_task_center/verification/intake.py | 86 +++++++++++ .../trial_task_center/verification/service.py | 136 ++++++++++++++++++ .../test_independent_verification_intake.py | 86 +++++++++++ 5 files changed, 324 insertions(+) create mode 100644 src/dx_productivity/trial_task_center/verification/intake.py create mode 100644 src/dx_productivity/trial_task_center/verification/service.py create mode 100644 tests/v1_1/test_independent_verification_intake.py diff --git a/src/dx_productivity/dsh/execution_runs.py b/src/dx_productivity/dsh/execution_runs.py index 978faf8..9f05a39 100644 --- a/src/dx_productivity/dsh/execution_runs.py +++ b/src/dx_productivity/dsh/execution_runs.py @@ -152,6 +152,15 @@ def _finish_execution_run(service, root, task_ids, stop, run_id, result, *, base receipt['reporting_errors'].append({'code': getattr(error, 'code', 'schedule_receipt_unavailable')}) _persist_execution_receipt(service, journal, run_id, receipt, baseline) raise + # Optional downstream delivery follows the durable replacement receipt. + # Delivery failure must never turn a saved replacement into a repeat request. + try: + verification = getattr(service, 'verification', None) + if verification is not None: + verification.receive_successful_results(receipt, submission_id='run:' + run_id) + except Exception as error: + receipt['reporting_errors'].append({'code': 'verification_delivery_pending', + 'error': type(error).__name__}) return receipt diff --git a/src/dx_productivity/trial_task_center/service.py b/src/dx_productivity/trial_task_center/service.py index 770224c..e295469 100644 --- a/src/dx_productivity/trial_task_center/service.py +++ b/src/dx_productivity/trial_task_center/service.py @@ -102,6 +102,13 @@ def _default_path_opener(path: Path) -> None: class TaskCenterService: """The only API used by UI workers and widgets.""" + @property + def verification(self): + if not hasattr(self, '_verification_service'): + from .verification.service import VerificationService + self._verification_service = VerificationService(self._store, self._logging.root) + return self._verification_service + def __init__( self, store: TaskStore, diff --git a/src/dx_productivity/trial_task_center/verification/intake.py b/src/dx_productivity/trial_task_center/verification/intake.py new file mode 100644 index 0000000..cc4922e --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/intake.py @@ -0,0 +1,86 @@ +"""Managed immutable inputs; native tools never receive arbitrary live paths.""" +import json +from pathlib import Path +import shutil +from uuid import uuid4 + +from .. import native_netlist +from ..batch_resources import write_record +from ..operation_control import check_cancelled +from ..native_inventory import _project_options +from .contracts import artifact_ref, fail + + +class ArtifactStore: + def __init__(self, data_root): + self.data_root = Path(data_root).resolve() + self.root = self.data_root/'verification'/'artifacts' + + def directory(self, identity): + artifact_ref({'manifest_id':identity,'sha256':'0'*64}) + path = self.root/identity + if path.resolve().parent != self.root.resolve(): fail('证据目录越界。') + return path + + def put(self, kind, payload, *, identity=None): + identity = identity or uuid4().hex + directory = self.directory(identity); directory.mkdir(parents=True,exist_ok=True) + manifest = directory/'manifest.json' + if manifest.exists(): fail('不可覆盖已有校验证据。') + write_record(manifest, {'schema_version':1,'kind':kind,'payload':payload}) + return {'manifest_id':identity,'sha256':native_netlist._hash(manifest)} + + def read(self, ref, kind): + artifact_ref(ref) + if not ref: fail('缺少校验证据。') + directory = self.directory(ref['manifest_id']) + path = directory/'manifest.json' + try: + if native_netlist._hash(path) != ref['sha256']: fail('证据清单摘要不符。') + manifest = json.loads(path.read_text(encoding='utf-8')) + if manifest.get('schema_version') != 1 or manifest.get('kind') != kind: fail('证据类型不符。') + payload = manifest['payload'] + if kind == 'snapshot': + capture_root = Path(payload['root']).resolve() + if capture_root != (directory/'capture').resolve(): fail('输入副本归属不符。') + for relative in payload['capture_hashes']: + if not (capture_root/relative).resolve().is_relative_to(capture_root): fail('输入文件越界。') + for key,relative in (('project_path','input.prj'),('database_path','database/icdb.dat')): + if Path(payload[key]).resolve() != (capture_root/relative).resolve(): fail('输入文件身份不符。') + native_netlist._check_capture(payload) + return payload + except (OSError,ValueError,KeyError,TypeError) as error: + fail(f'校验证据不可用:{error}', 'verification_evidence') + + def capture(self, project, *, stop_event): + check_cancelled(stop_event) + identity = uuid4().hex + capture = native_netlist.capture_project(Path(project),self.directory(identity)/'capture') + check_cancelled(stop_event) + return self.put('snapshot',capture,identity=identity) + + def adopt(self, capture): + root = Path(capture['root']).resolve() + if not root.is_relative_to(self.data_root): fail('交接副本不属于当前任务库。') + native_netlist._check_capture(capture) + identity = uuid4().hex + destination = self.directory(identity)/'capture' + destination.mkdir(parents=True) + for relative, sha in capture['capture_hashes'].items(): + source = (root/relative).resolve(); target=(destination/relative).resolve() + if not source.is_relative_to(root) or not target.is_relative_to(destination.resolve()): fail('交接文件路径越界。') + target.parent.mkdir(parents=True,exist_ok=True); shutil.copyfile(source,target) + if native_netlist._hash(target) != sha: fail('交接副本在复制时变化。') + value = dict(capture,root=str(destination),project_path=str(destination/'input.prj'), + database_path=str(destination/'database/icdb.dat'),manifest_path=str(destination/'capture.json')) + native_netlist._check_capture(capture) + write_record(destination/'capture.json',value) + return self.put('snapshot',value,identity=identity) + + +def validate_pair(before, after): + before,after = Path(before).resolve(strict=True),Path(after).resolve(strict=True) + if before==after or before.samefile(after): fail('请选择不同的前后工程。','verification_same_source') + before_db,after_db = _project_options(before)[3],_project_options(after)[3] + if Path(before_db).samefile(after_db): fail('两个工程引用同一个数据库。','verification_same_source') + return before,after diff --git a/src/dx_productivity/trial_task_center/verification/service.py b/src/dx_productivity/trial_task_center/verification/service.py new file mode 100644 index 0000000..afd407b --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/service.py @@ -0,0 +1,136 @@ +"""One interface for standalone verification and successful-result handoff.""" +import json +from pathlib import Path +from threading import RLock +from uuid import uuid4 + +from ..batch_resources import write_record +from ..operation_control import check_cancelled +from .contracts import default_plan, digest, fail, identifier +from .intake import ArtifactStore, validate_pair +from .store import VerificationRepository + + +class VerificationService: + def __init__(self, task_store, data_root): + self.repo = VerificationRepository(task_store) + self.data_root = Path(data_root).resolve() + self.artifacts = ArtifactStore(self.data_root) + self._intake_lock = RLock() + + def create_task(self, name, *, request_id): + return self.repo.create_task(name,request_id=request_id) + + def publish_inputs(self, task_id, inputs, *, submission_id): + body = {'task_id':task_id,'inputs':inputs} + with self.repo.store._lock: + old = self.repo._request('ingest',submission_id,body) + if old is not None: return old + normalized=[] + for value in inputs: + if not isinstance(value,dict): + normalized.append(value) + continue + row=dict(value) + try: + for field,kind in (('before_ref','snapshot'),('after_ref','snapshot'),('expectation_ref','expectations')): + if row.get(field): self.artifacts.read(row[field],kind) + except (ValueError,OSError) as error: + row['unavailable_reason']=str(error) + normalized.append(row) + with self.repo.store.transaction(): + old=self.repo._request('ingest',submission_id,body) + if old is not None:return old + result=self.repo.publish(task_id,tuple(normalized),submission_id='ingest:'+submission_id) + return self.repo._remember('ingest',submission_id,body,result) + + def import_pair(self, task_id, before, after, *, request_id, stop_event): + body=[task_id,str(before),str(after)] + with self._intake_lock: + with self.repo.store._lock: + old=self.repo._request('import',request_id,body) + if old is not None:return old + check_cancelled(stop_event) + self.repo.task(task_id) + try: before,after=validate_pair(before,after) + except OSError as error: fail(f'工程文件不可用:{error}') + left=self.artifacts.capture(before,stop_event=stop_event) + right=self.artifacts.capture(after,stop_event=stop_event) + row={'item_key':uuid4().hex,'project_key':digest([str(before),str(after)]), + 'display_name':after.stem,'input_version':1,'before_ref':left,'after_ref':right, + 'expectation_ref':None,'check_plan':default_plan()} + check_cancelled(stop_event) + with self.repo.store.transaction(): + result=self.publish_inputs(task_id,(row,),submission_id='import:'+request_id) + return self.repo._remember('import',request_id,body,result) + + def receive_successful_results(self, result_ref, *, submission_id): + with self._intake_lock: + with self.repo.store._lock: + old=self.repo._request('handoff',submission_id,result_ref) + if old is not None:return old + reports=result_ref.get('netlist_verification') or {} + candidates=[] + for key,report in reports.items(): + execution=report.get('execution') or {} + if execution.get('state')=='completed' and (execution.get('saved_items') or 0)>0: + candidates.append((key,report)) + # A successful save without optional netlist evidence is still visible. + for task in result_ref.get('tasks',()): + if task.get('state')=='completed' and (task.get('saved_items') or 0)>0 and task['task_id'] not in reports: + candidates.append((task['task_id'],{'execution':{'state':'completed','saved_items':task['saved_items']}, + 'project_path':task.get('name',task['task_id'])})) + empty={key:[] for key in ('accepted','duplicates','stale_ignored','rejected')} + if not candidates:return empty + run_key=identifier(str(result_ref.get('queue_id') or result_ref.get('run_id') or submission_id)) + task=self.create_task('校验任务',request_id='handoff-task:'+run_key)['task_id'] + rows=[] + for key,report in candidates: + delivery_key=digest([run_key,key,report]) + with self.repo.store._lock: + prior=self.repo._request('handoff-row',delivery_key,report) + if prior is not None: + rows.append(prior) + continue + refs={}; reason='' + try: + for phase in ('before','after'): + evidence=report.get(phase) or {} + path=Path(evidence.get('export_path','')).resolve() + if not path.is_relative_to(self.data_root) or not path.is_file(): fail('缺少可信前后副本。') + from ..native_netlist import _hash + if _hash(path)!=evidence.get('export_sha256'):fail('交接导出摘要不符。') + exported=json.loads(path.read_text(encoding='utf-8')) + refs[phase]=self.artifacts.adopt(exported['capture']) + except (ValueError,OSError,KeyError,TypeError) as error: reason=str(error) + expected=None + if not reason and 'expected_changes' in report: + expected=self.artifacts.put('expectations',{'changes':report['expected_changes'], + 'symbols':report.get('expected_symbols',{}),'execution':report.get('execution',{})}) + plan=default_plan() + if expected:plan['required_checks'].append('declared_attributes') + row={'item_key':str(key),'project_key':str(report.get('project_path') or key), + 'display_name':Path(str(report.get('project_path') or key)).stem,'input_version':1, + 'before_ref':refs.get('before'),'after_ref':refs.get('after'), + 'expectation_ref':expected,'check_plan':plan,'unavailable_reason':reason} + with self.repo.store.transaction(): + self.repo._remember('handoff-row',delivery_key,report,row) + rows.append(row) + with self.repo.store.transaction(): + result=self.publish_inputs(task,tuple(rows),submission_id='handoff:'+submission_id) + result['task_id']=task + return self.repo._remember('handoff',submission_id,result_ref,result) + + def reconcile_deliveries(self, *, limit=100): + result={'accepted':0,'errors':[]} + # Completed queue checkpoints are durable and exist independently of a UI callback. + directory=self.data_root/'task-queues' + for path in sorted(directory.glob('*.json'),key=lambda p:p.stat().st_mtime,reverse=True)[:limit]: + try: + value=json.loads(path.read_text(encoding='utf-8')) + value.setdefault('run_id',path.stem) + record=self.receive_successful_results(value,submission_id='checkpoint:'+digest(value)) + result['accepted']+=len(record['accepted']) + except (ValueError,OSError,KeyError,TypeError) as error: + result['errors'].append({'record':path.name,'reason':str(error)}) + return result diff --git a/tests/v1_1/test_independent_verification_intake.py b/tests/v1_1/test_independent_verification_intake.py new file mode 100644 index 0000000..a46300f --- /dev/null +++ b/tests/v1_1/test_independent_verification_intake.py @@ -0,0 +1,86 @@ +from pathlib import Path +from threading import Event +import json +import pytest +from dx_productivity.trial_task_center.store import TaskStore +from dx_productivity.trial_task_center.errors import TaskCenterError +from test_native_cli_netlist import project_fixture + + +@pytest.fixture +def service(tmp_path): + from dx_productivity.trial_task_center.verification.service import VerificationService + store = TaskStore(tmp_path/'tasks.db') + try: yield VerificationService(store,tmp_path/'data') + finally: store.close() + + +def test_pair_import_creates_same_input_contract_without_replacement(service,tmp_path): + a = tmp_path/'a'; b = tmp_path/'b'; a.mkdir(); b.mkdir() + before,after = project_fixture(a),project_fixture(b) + task = service.create_task('独立任务',request_id='create')['task_id'] + result = service.import_pair(task,before,after,request_id='import',stop_event=Event()) + item = result['accepted'][0]['item_id'] + row = service.repo.revision(item,1)['payload'] + assert row['input_state']=='ready' and row['expectation_ref'] is None + assert service.import_pair(task,before,after,request_id='import',stop_event=Event())==result + assert service.repo.latest_attempt(item,1) is None + before_capture = service.artifacts.read(row['before_ref'],'snapshot') + assert Path(before_capture['database_path']).read_bytes()==b'saved-database' + Path(before_capture['database_path']).write_bytes(b'tampered') + with pytest.raises(TaskCenterError): service.artifacts.read(row['before_ref'],'snapshot') + + +def test_same_source_and_cancel_do_not_publish_items(service,tmp_path): + project = project_fixture(tmp_path) + task = service.create_task('任务',request_id='c')['task_id'] + with pytest.raises(TaskCenterError): service.import_pair(task,project,project,request_id='i',stop_event=Event()) + stopped=Event(); stopped.set() + with pytest.raises(TaskCenterError): service.import_pair(task,project,project,request_id='j',stop_event=stopped) + assert service.repo.connection.execute('SELECT COUNT(*) FROM verification_items').fetchone()[0]==0 + + +def test_missing_handoff_evidence_remains_visible_and_duplicate_delivery_does_not_repeat(service): + report={'task_id':'execution-task','project_path':'F:/board.prj', + 'execution':{'state':'completed','saved_items':1},'status':'unavailable','reason':'capture failed'} + result=service.receive_successful_results({'run_id':'run','netlist_verification':{'execution-task':report}},submission_id='handoff') + item=result['accepted'][0]['item_id'] + assert service.repo.revision(item,1)['payload']['input_state']=='unavailable' + assert service.receive_successful_results({'run_id':'run','netlist_verification':{'execution-task':report}},submission_id='handoff')==result + assert service.repo.connection.execute('SELECT COUNT(*) FROM verification_items').fetchone()[0]==1 + + +def test_unsaved_handoff_is_not_accepted_as_success(service): + report={'task_id':'e','project_path':'F:/board.prj','execution':{'state':'failed','saved_items':0}} + result=service.receive_successful_results({'run_id':'r','netlist_verification':{'e':report}},submission_id='bad') + assert not result['accepted'] + + +def test_artifact_reference_cannot_escape_managed_directory(service): + with pytest.raises(TaskCenterError): + service.artifacts.read({'manifest_id':'../../secret','sha256':'1'*64},'snapshot') + + +def test_malformed_row_does_not_block_good_rows(service): + task=service.create_task('任务',request_id='c')['task_id'] + result=service.publish_inputs(task,(None,{}),submission_id='mixed') + assert len(result['rejected'])==2 + + +def test_complete_delivery_can_be_reconciled_under_another_notification(service,tmp_path): + from dx_productivity.trial_task_center.native_netlist import capture_project, _hash + reports={} + for phase in ('before','after'): + folder=tmp_path/phase; folder.mkdir() + capture=capture_project(project_fixture(folder),service.data_root/phase/'capture') + path=service.data_root/phase/'export.json' + path.write_text(json.dumps({'capture':capture}),encoding='utf-8') + reports[phase]={'export_path':str(path),'export_sha256':_hash(path)} + reports.update(project_path='board.prj',execution={'state':'completed','saved_items':1},expected_changes={}) + receipt={'run_id':'r','queue_id':'q','netlist_verification':{'e':reports}} + first=service.receive_successful_results(receipt,submission_id='receipt') + checkpoint=dict(receipt); checkpoint['run_id']='q' + second=service.receive_successful_results(checkpoint,submission_id='checkpoint') + assert len(first['accepted'])==1 + assert len(second['duplicates'])==1 and not second['rejected'] + assert second['task_id']==first['task_id'] -- 2.39.5 From b3c8c9c1262529aab7a0648386bf61194259c39f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=98=BF=E7=99=BD=E5=8F=94?= <11794527+absfan@user.noreply.gitee.com> Date: Tue, 17 Nov 2026 15:37:52 +0800 Subject: [PATCH 05/27] feat: query current verification results and task summaries --- .../trial_task_center/verification/queries.py | 107 ++++++++++++++++++ .../trial_task_center/verification/service.py | 7 ++ .../test_independent_verification_queries.py | 41 +++++++ 3 files changed, 155 insertions(+) create mode 100644 src/dx_productivity/trial_task_center/verification/queries.py create mode 100644 tests/v1_1/test_independent_verification_queries.py diff --git a/src/dx_productivity/trial_task_center/verification/queries.py b/src/dx_productivity/trial_task_center/verification/queries.py new file mode 100644 index 0000000..b6929c3 --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/queries.py @@ -0,0 +1,107 @@ +"""Snapshot projections: only the current input and latest attempt drive badges.""" +import json +from .contracts import ACTIVE, digest, fail + + +def checkpoint(control): + if control is not None: control.checkpoint() + + +def project(row): + row=dict(row) + state=row.get('attempt_state') + verdict=row.get('verdict') + if row['input_state']!='ready': status='unavailable' + elif state in ACTIVE: status='running' + elif state=='cancelled' and row.get('reason')=='run_stopped_before_dispatch': status='waiting' + elif state=='cancelled': status='stopped' + elif state=='interrupted': status='interrupted' + elif state=='failed': status='unavailable' + elif state=='succeeded': status={'CONSISTENT':'consistent','WARNING':'warning','DIFFERENT':'different'}.get(verdict,'unavailable') + else: status='waiting' + row.update(status=status,can_start=row['input_state']=='ready' and state not in ACTIVE, + scope='已核对换料规则' if row.get('expectation_ref') else '未核对换料规则') + return row + + +def summarize_items(rows): + summary=dict.fromkeys(('total','processed','consistent','warning','different','unavailable','waiting','running','stopped','interrupted'),0) + for row in rows: + summary['total']+=1; summary[row['status']]+=1 + if row['status'] in {'consistent','warning','different','unavailable'}: summary['processed']+=1 + return summary + + +def paginate(rows,cursor,limit,binding,maximum): + if type(limit) is not int or not 1<=limit<=maximum: fail('分页大小超出范围。') + offset=0 + if cursor is not None: + if not isinstance(cursor,dict) or cursor.get('binding')!=binding or type(cursor.get('offset')) is not int or cursor['offset']<0: + fail('列表已更新,请刷新后重试。','verification_cursor') + offset=cursor['offset'] + return rows[offset:offset+limit],({'offset':offset+limit,'binding':binding} if len(rows)>offset+limit else None) + + +class VerificationQueries: + def __init__(self,repo):self.repo=repo + + def _rows(self,task_id,control=None): + checkpoint(control) + rows=self.repo.connection.execute('''SELECT i.*, r.input_version, + json_extract(r.payload_json,'$.input_state') input_state, + json_extract(r.payload_json,'$.unavailable_reason') unavailable_reason, + json_extract(r.payload_json,'$.expectation_ref') expectation_ref, + a.attempt_id,a.state attempt_state,a.generation,a.reason, + json_extract(a.result_json,'$.verdict') verdict + FROM verification_items i JOIN verification_input_revisions r + ON r.item_id=i.item_id AND r.input_version=i.current_version + LEFT JOIN verification_attempts a ON a.attempt_id=(SELECT attempt_id FROM verification_attempts + WHERE item_id=i.item_id AND input_version=i.current_version ORDER BY generation DESC LIMIT 1) + WHERE i.task_id=? ORDER BY i.rowid''',(task_id,)).fetchall() + return [project(row) for row in rows] + + def list_tasks(self,*,query='',cursor=None,limit=50,read_control=None): + with self.repo.store.transaction(): + tasks=[] + for row in self.repo.connection.execute('SELECT * FROM verification_tasks ORDER BY created DESC,task_id').fetchall(): + checkpoint(read_control) + row=dict(row) + if query.casefold() in row['name'].casefold(): + row['summary']=summarize_items(self._rows(row['task_id'],read_control));tasks.append(row) + binding=digest([query,[(r['task_id'],r['view_revision']) for r in tasks]]) + page,next_cursor=paginate(tasks,cursor,limit,binding,50) + return {'tasks':page,'cursor':next_cursor} + + def read_task(self,task_id,*,state='',query='',cursor=None,limit=100,read_control=None): + with self.repo.store.transaction(): + task=self.repo.task(task_id);rows=self._rows(task_id,read_control) + filtered=[] + for row in rows: + checkpoint(read_control) + if state and row['status']!=state:continue + text=row['display_name']+' '+row['project_key'] + if query and row.get('attempt_id'): + text+=' '+(self.repo.attempt(row['attempt_id'])['result_json'] or '') + if query.casefold() in text.casefold():filtered.append(row) + binding=digest([task_id,task['view_revision'],state,query]) + page,next_cursor=paginate(filtered,cursor,limit,binding,100) + return dict(task,items=page,cursor=next_cursor,summary=summarize_items(rows)) + + def read_item(self,item_id,*,version=None,read_control=None): + with self.repo.store.transaction(): + checkpoint(read_control) + item=self.repo.item(item_id);version=version or item['current_version'] + revision=self.repo.revision(item_id,version);attempt=self.repo.latest_attempt(item_id,version) + row=dict(item,**{k:v for k,v in revision['payload'].items() if k not in item}) + row.update(input_version=version,attempt_id=attempt['attempt_id'] if attempt else None, + attempt_state=attempt['state'] if attempt else None,reason=attempt['reason'] if attempt else '', + verdict=(attempt['result'] or {}).get('verdict') if attempt else None) + history=[dict(r) for r in self.repo.connection.execute('SELECT input_version,generation,attempt_id,state FROM verification_attempts WHERE item_id=? ORDER BY input_version DESC,generation DESC',(item_id,))] + return dict(project(row),payload=revision['payload'],attempt=attempt,history=history) + + def read_issues(self,attempt_id,*,kind='',cursor=None,limit=100,read_control=None): + checkpoint(read_control) + attempt=self.repo.attempt(attempt_id) + rows=[r for r in (attempt['result'] or {}).get('issues',()) if not kind or r.get('check_id')==kind] + page,next_cursor=paginate(rows,cursor,limit,digest([attempt_id,attempt['updated'],kind]),100) + return {'issues':page,'cursor':next_cursor} diff --git a/src/dx_productivity/trial_task_center/verification/service.py b/src/dx_productivity/trial_task_center/verification/service.py index afd407b..eed783f 100644 --- a/src/dx_productivity/trial_task_center/verification/service.py +++ b/src/dx_productivity/trial_task_center/verification/service.py @@ -17,6 +17,13 @@ class VerificationService: self.data_root = Path(data_root).resolve() self.artifacts = ArtifactStore(self.data_root) self._intake_lock = RLock() + from .queries import VerificationQueries + self.queries = VerificationQueries(self.repo) + + def list_tasks(self, **kwargs): return self.queries.list_tasks(**kwargs) + def read_task(self, task_id, **kwargs): return self.queries.read_task(task_id, **kwargs) + def read_item(self, item_id, **kwargs): return self.queries.read_item(item_id, **kwargs) + def read_issues(self, attempt_id, **kwargs): return self.queries.read_issues(attempt_id, **kwargs) def create_task(self, name, *, request_id): return self.repo.create_task(name,request_id=request_id) diff --git a/tests/v1_1/test_independent_verification_queries.py b/tests/v1_1/test_independent_verification_queries.py new file mode 100644 index 0000000..c3e3714 --- /dev/null +++ b/tests/v1_1/test_independent_verification_queries.py @@ -0,0 +1,41 @@ +from test_independent_verification_store import repo +from test_independent_verification_contracts import payload + + +def test_current_counts_and_attempt_replacement(repo): + from dx_productivity.trial_task_center.verification.queries import VerificationQueries + task=repo.create_task('相同名称',request_id='c')['task_id'] + for n in range(24): + row=payload(); row['item_key']=str(n) + if n==19: row['before_ref']=None + item=repo.publish(task,(row,),submission_id=str(n))['accepted'][0]['item_id'] + if n<19: + a=repo.create_attempt(item,1,request_id='a'+str(n)); repo.claim(a['attempt_id'],owner_id='o') + verdict='CONSISTENT' if n<16 else 'WARNING' if n<18 else 'DIFFERENT' + repo.finish(a['attempt_id'],generation=1,result={'resource_state':'released','verdict':verdict}) + queries=VerificationQueries(repo) + page=queries.read_task(task,limit=10) + assert page['summary']==dict(total=24,processed=20,consistent=16,warning=2,different=1,unavailable=1,waiting=4,running=0,stopped=0,interrupted=0) + assert len(page['items'])==10 and page['cursor'] + assert len(queries.read_task(task,cursor=page['cursor'],limit=10)['items'])==10 + first=page['items'][0] + repo.create_attempt(first['item_id'],1,request_id='again') + assert queries.read_task(task)['summary']['consistent']==15 + + +def test_new_version_has_no_old_green_and_filters_are_literal(repo): + from dx_productivity.trial_task_center.verification.queries import VerificationQueries + from dx_productivity.trial_task_center.errors import TaskCenterError + import pytest + task=repo.create_task('任务',request_id='c')['task_id'] + row=payload(); row['display_name']='100%_board' + item=repo.publish(task,(row,),submission_id='s')['accepted'][0]['item_id'] + a=repo.create_attempt(item,1,request_id='a'); repo.claim(a['attempt_id'],owner_id='o') + repo.finish(a['attempt_id'],generation=1,result={'resource_state':'released','verdict':'CONSISTENT'}) + row['input_version']=2; repo.publish(task,(row,),submission_id='new') + q=VerificationQueries(repo) + assert q.read_item(item)['status']=='waiting' + assert q.read_item(item,version=1)['status']=='consistent' + assert len(q.read_task(task,query='%_')['items'])==1 + assert not q.read_task(task,query='missing')['items'] + with pytest.raises(TaskCenterError):q.read_task(task,cursor={'offset':1,'binding':'bad'}) -- 2.39.5 From 4da211d5d2220dd1d4c00c4ef7a7df07a0f160fd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=98=BF=E7=99=BD=E5=8F=94?= <11794527+absfan@user.noreply.gitee.com> Date: Tue, 17 Nov 2026 15:40:23 +0800 Subject: [PATCH 06/27] feat: execute independent verification on immutable inputs --- .../trial_task_center/verification/runner.py | 68 +++++++++++++++++++ .../test_independent_verification_runner.py | 46 +++++++++++++ 2 files changed, 114 insertions(+) create mode 100644 src/dx_productivity/trial_task_center/verification/runner.py create mode 100644 tests/v1_1/test_independent_verification_runner.py diff --git a/src/dx_productivity/trial_task_center/verification/runner.py b/src/dx_productivity/trial_task_center/verification/runner.py new file mode 100644 index 0000000..caefcde --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/runner.py @@ -0,0 +1,68 @@ +"""Independent native read-only execution. No replacement or CAD mutation entrypoints.""" +from pathlib import Path +from threading import Lock +from uuid import uuid4 + +from .. import native_netlist, netlist_verification +from ..batch_resources import pending_resources +from ..operation_control import check_cancelled +from .contracts import rollup_results + +_native_lock=Lock() + + +def can_start_native_export(service): + with service.repo.store._lock: + held=service.repo.connection.execute("SELECT 1 FROM verification_attempts WHERE state='stopping' OR resource_state='unknown' LIMIT 1").fetchone() + if held or pending_resources(service.data_root):return {'allowed':False,'reason':'资源退出尚未确认'} + return {'allowed':not _native_lock.locked(),'reason':'原生导出忙' if _native_lock.locked() else ''} + + +def export_inputs(service,before_ref,after_ref,*,output,stop_event): + before=service.artifacts.read(before_ref,'snapshot') + after=service.artifacts.read(after_ref,'snapshot') + left=netlist_verification._export_saved_capture(before,Path(output)/'before',stop_event=stop_event) + if left.get('cleanup_uncertain'):return left,{} + check_cancelled(stop_event) + right=netlist_verification._export_saved_capture(after,Path(output)/'after',stop_event=stop_event) + return left,right + + +def run_attempt(service,attempt_id,*,stop_event): + if not can_start_native_export(service)['allowed'] or not _native_lock.acquire(blocking=False): + return {'published':False,'waiting':True} + attempt=None + try: + check_cancelled(stop_event) + attempt=service.repo.claim(attempt_id,owner_id=uuid4().hex) + if attempt is None:return {'published':False} + payload=service.repo.revision(attempt['item_id'],attempt['input_version'])['payload'] + output=service.data_root/'verification'/'attempts'/attempt_id + left,right=export_inputs(service,payload['before_ref'],payload['after_ref'],output=output,stop_event=stop_event) + if left.get('cleanup_uncertain') or right.get('cleanup_uncertain'): + with service.repo.store.transaction(): + service.repo.connection.execute("UPDATE verification_attempts SET state='stopping',resource_state='unknown',reason=? WHERE attempt_id=?",('原生资源退出未知',attempt_id)) + return {'published':False,'blocked':True} + check_cancelled(stop_event) + expected=service.artifacts.read(payload['expectation_ref'],'expectations') if payload['expectation_ref'] else None + comparison=native_netlist.compare_netlists(left,right,expected_changes=(expected or {}).get('changes')) + checks=[{'check_id':'inputs','state':'equal'}, + {'check_id':'coverage','state':'equal' if comparison['status']!='unavailable' else 'unknown'}] + result=dict(rollup_results(checks,required_checks=payload['check_plan']['required_checks']), + checks=checks,issues=[],before=left,after=right,attempt_state='succeeded',resource_state='released') + result.update(item_id=attempt['item_id'],input_version=attempt['input_version'],attempt_id=attempt_id, + generation=attempt['generation'],input_digest=payload['payload_digest'],policy=payload['check_plan']) + ref=service.artifacts.put('result',result) + result['result_ref']=ref + check_cancelled(stop_event) + published=service.repo.finish(attempt_id,generation=attempt['generation'],result=result) + return dict(result,published=published) + except Exception as error: + if attempt: + cancelled=getattr(error,'code','')=='operation_cancelled' + result={'attempt_state':'cancelled' if cancelled else 'failed','resource_state':'released', + 'verdict':'INCOMPLETE','reason':str(error),'checks':[],'issues':[]} + service.repo.finish(attempt_id,generation=attempt['generation'],result=result) + return {'published':False,'reason':str(error)} + finally: + _native_lock.release() diff --git a/tests/v1_1/test_independent_verification_runner.py b/tests/v1_1/test_independent_verification_runner.py new file mode 100644 index 0000000..098c7cf --- /dev/null +++ b/tests/v1_1/test_independent_verification_runner.py @@ -0,0 +1,46 @@ +from threading import Event +from test_independent_verification_intake import service +from test_native_cli_netlist import project_fixture, graph + + +def imported(service,tmp_path): + a=tmp_path/'a';b=tmp_path/'b';a.mkdir();b.mkdir() + task=service.create_task('独立',request_id='c')['task_id'] + item=service.import_pair(task,project_fixture(a),project_fixture(b),request_id='i',stop_event=Event())['accepted'][0]['item_id'] + return task,item + + +def test_runner_uses_frozen_captures_and_publishes_attempt(service,tmp_path,monkeypatch): + from dx_productivity.trial_task_center.verification.runner import run_attempt + from dx_productivity.trial_task_center import netlist_verification + task,item=imported(service,tmp_path) + before=service.repo.revision(item,1)['payload'] + captured=service.artifacts.read(before['before_ref'],'snapshot') + original=open(captured['database_path'],'rb').read() + calls=[] + def export(capture,directory,*,stop_event): + calls.append(capture['root']) + directory.mkdir(parents=True,exist_ok=True) + return {'status':'success','complete':True,'graph':graph(directory),'outputs':{}} + monkeypatch.setattr(netlist_verification,'_export_saved_capture',export) + attempt=service.repo.create_attempt(item,1,request_id='a') + result=run_attempt(service,attempt['attempt_id'],stop_event=Event()) + assert result['published'] and len(calls)==2 + assert service.repo.attempt(attempt['attempt_id'])['state']=='succeeded' + assert open(captured['database_path'],'rb').read()==original + assert service.repo.store._connection.execute('SELECT COUNT(*) FROM execution_operations').fetchone()[0]==0 + assert not run_attempt(service,attempt['attempt_id'],stop_event=Event())['published'] + + +def test_corrupt_input_does_not_export_and_failure_is_not_green(service,tmp_path,monkeypatch): + from dx_productivity.trial_task_center.verification.runner import run_attempt + from dx_productivity.trial_task_center import netlist_verification + _,item=imported(service,tmp_path) + capture=service.artifacts.read(service.repo.revision(item,1)['payload']['before_ref'],'snapshot') + open(capture['database_path'],'wb').write(b'corrupt') + def forbidden(*a,**k):raise AssertionError('must not export corrupt capture') + monkeypatch.setattr(netlist_verification,'_export_saved_capture',forbidden) + attempt=service.repo.create_attempt(item,1,request_id='a') + run_attempt(service,attempt['attempt_id'],stop_event=Event()) + assert service.repo.attempt(attempt['attempt_id'])['state']=='failed' + assert service.read_item(item)['status']=='unavailable' -- 2.39.5 From de486a9c6be2b12016f02a1da93fedd3f5ec3c30 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=98=BF=E7=99=BD=E5=8F=94?= <11794527+absfan@user.noreply.gitee.com> Date: Tue, 17 Nov 2026 15:42:19 +0800 Subject: [PATCH 07/27] feat: classify verification checks with explicit evidence and coverage --- .../trial_task_center/verification/rules.py | 152 ++++++++++++++++++ .../trial_task_center/verification/runner.py | 8 +- .../test_independent_verification_rules.py | 86 ++++++++++ 3 files changed, 241 insertions(+), 5 deletions(-) create mode 100644 src/dx_productivity/trial_task_center/verification/rules.py create mode 100644 tests/v1_1/test_independent_verification_rules.py diff --git a/src/dx_productivity/trial_task_center/verification/rules.py b/src/dx_productivity/trial_task_center/verification/rules.py new file mode 100644 index 0000000..24a5744 --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/rules.py @@ -0,0 +1,152 @@ +"""Electrical comparison at fixed instance/refdes/physical-pin identities.""" +from collections import Counter, defaultdict +from .contracts import CHECKS, digest, rollup_results, validate_plan +from ..native_netlist import _is_pcb, _proven_symbol + + +def component_key(uid,row): + scope=row.get('instance_path',uid.rpartition('/')[0]) or 'root' + ref=row.get('refdes') or row.get('attributes',{}).get('Ref Designator') + return (scope,ref) if ref else None + + +def component_index(graph): + index={};ambiguous=[] + for uid,row in graph.get('components',{}).items(): + if not _is_pcb(row):continue + key=component_key(uid,row) + if key is None or key in index:ambiguous.append(key) + else:index[key]=(uid,row) + return index,ambiguous + + +def match_components(before_graph,after_graph): + left,la=component_index(before_graph);right,ra=component_index(after_graph) + return {'before':left,'after':right,'ambiguous':la+ra, + 'matches':{key:(left[key][0],right[key][0]) for key in left.keys()&right.keys()}} + + +def physical_view(graph): + """Keep unknowns explicit; networks include self to distinguish singles from open pins.""" + indexed,ambiguous=component_index(graph) + if ambiguous:raise ValueError('位号或实例范围对应不唯一') + endpoints={};pins={} + for uid,row in graph.get('components',{}).items(): + pcb=_is_pcb(row);key=component_key(uid,row) + for name,pin in row.get('pins',{}).items(): + number=pin.get('number') if pcb else name + if pcb and (key is None or not number):raise ValueError('缺少物理脚号') + endpoint=(*key,str(number)) if key else ('native',uid,name) + if endpoint in pins:raise ValueError('物理脚号重复,无法唯一绑定') + endpoints[(uid,name)]=endpoint + pins[endpoint]={'logical_name':name,'number':str(number),'nets':[], + 'uid':uid,'raw_key':['components',uid,'pins',name], + 'declared_nets':pin.get('nets')} + seen=defaultdict(list) + for net in graph.get('nets',()): + members=[] + for uid,name in net['endpoints']: + if (uid,name) not in endpoints:raise ValueError('网表端点未覆盖') + members.append(endpoints[(uid,name)]) + if len(set(members))!=len(members):raise ValueError('网络含重复物理端点') + for endpoint in members: + record={'name':net['name'],'endpoints':[list(e) for e in sorted(members)]} + pins[endpoint]['nets'].append(record);seen[endpoint].append(net['name']) + for endpoint,pin in pins.items(): + if pin['declared_nets'] is None or Counter(pin['declared_nets'])!=Counter(seen[endpoint]): + raise ValueError('引脚与网络互反覆盖不完整') + pin['nets'].sort(key=lambda n:(n['name'],n['endpoints'])) + return pins + + +def evaluate(before,after,*,expectations,check_plan,pin_metadata=None): + plan=validate_plan(check_plan) + requested=set(plan['required_checks'])|set(plan['optional_checks']) + states={key:'unknown' if key in requested else 'not_requested' for key in CHECKS} + issues=[] + rank={'not_requested':0,'equal':1,'expected_change':2,'unknown':3,'warning':4,'error':5} + def issue(check,state,reason,*,key=None,pin=None,left=None,right=None,field=None): + # Hard facts stay visible even if a user did not request optional enrichment. + if rank[state]>rank.get(states[check],0) or states[check]=='unknown':states[check]=state + row={'check_id':check,'state':state,'reason':reason,'before':left,'after':right} + if key:row.update(instance_path=key[0],refdes=key[1]) + if pin is not None:row['pin_number']=pin + if field:row['field']=field + row['issue_id']=digest(row)[:24];issues.append(row) + states['inputs']='equal' + complete=all(e.get('status')=='success' and e.get('complete') is True and e.get('graph',{}).get('components') for e in (before,after)) + left=before.get('graph',{});right=after.get('graph',{}) + states['coverage']='equal' if complete else 'unknown' + if not complete: + issue('coverage','unknown','缺少完整原生导出',left=before.get('reason'),right=after.get('reason')) + matched=match_components(left,right) + if complete and not matched['ambiguous']: + states['components']='equal' + for key in sorted(matched['before'].keys()^matched['after'].keys()): + issue('components','error','器件位号或实例范围增减',key=key, + left=key in matched['before'],right=key in matched['after']) + else:issue('components','unknown','器件身份或覆盖无法唯一证明') + views=[] + try: + if not complete:raise ValueError('导出不完整') + views=[physical_view(left),physical_view(right)] + except (ValueError,KeyError,TypeError) as error: + issue('coverage','unknown',str(error)) + if views: + states['physical_pins']=states['connections']=states['net_names']='equal' + states['pin_text']='equal' if 'pin_text' in requested else 'not_requested' + states['pin_semantics']='equal' if 'pin_semantics' in requested else 'not_requested' + lp,rp=views + for key in sorted(matched['matches']): + lset={e[2] for e in lp if e[:2]==key};rset={e[2] for e in rp if e[:2]==key} + if lset!=rset:issue('physical_pins','error','物理脚号集合变化',key=key,left=sorted(lset),right=sorted(rset)) + for endpoint in sorted(lp.keys()&rp.keys()): + l,r=lp[endpoint],rp[endpoint];key=endpoint[:2];pin=endpoint[2] + lt=sorted(n['endpoints'] for n in l['nets']);rt=sorted(n['endpoints'] for n in r['nets']) + if lt!=rt:issue('connections','error','固定物理脚号的连接变化',key=key,pin=pin,left=l,right=r) + elif [n['name'] for n in l['nets']]!=[n['name'] for n in r['nets']]: + issue('net_names','error','网络名称变化,需确认',key=key,pin=pin,left=l,right=r) + if l['logical_name']!=r['logical_name'] and 'pin_text' in requested: + issue('pin_text','warning','引脚名称变化,需人工确认功能',key=key,pin=pin,left=l,right=r) + if {l['logical_name'].upper(),r['logical_name'].upper()} & {'GND','VCC','VDD','VSS'}: + issue('pin_semantics','warning','疑似电源或地功能变化,高关注',key=key,pin=pin,left=l,right=r) + declared=expectations is not None + states['declared_attributes']='equal' if declared else 'not_requested' + states['attribute_changes']='equal' if 'attribute_changes' in requested else 'not_requested' + changes=(expectations or {}).get('changes',{}) + symbols=(expectations or {}).get('symbols',{}) + used=set() + for key,(lid,rid) in matched['matches'].items(): + l,r=left['components'][lid],right['components'][rid] + expected=dict(l.get('attributes',{}));delta=changes.get(lid,changes.get(key[1],{}));used.add(lid);used.add(key[1]) + for name,value in delta.items(): + if value is None:expected.pop(name,None) + else:expected[name]=value + actual=r.get('attributes',{}) + if declared: + if actual!=expected:issue('declared_attributes','error','器件属性与固定预期不符',key=key,left=expected,right=actual,field='attributes') + elif delta:states['declared_attributes']='expected_change' if states['declared_attributes']!='error' else 'error' + elif actual!=expected:issue('attribute_changes','warning','器件属性变化;未核对换料规则',key=key,left=expected,right=actual,field='attributes') + proof=symbols.get(lid) + proven=proof is not None and _proven_symbol(l,r,proof) + if proof is not None and not proven:issue('declared_attributes','error','目标符号证明无法绑定',key=key,left=l.get('symbol'),right=r.get('symbol')) + for field in ('symbol','other_attributes','ambiguous_attributes'): + if field=='symbol' and proven:continue + if l.get(field)!=r.get(field):issue('declared_attributes' if declared else 'attribute_changes', + 'error' if declared else 'warning','符号或其他属性变化',key=key,left=l.get(field),right=r.get(field),field=field) + for missing in set(changes)-used:issue('declared_attributes','error','预期清单目标未找到',left=missing) + # Proven metadata is enrichment; never substitute component Value for pin Value. + if pin_metadata: + for key in ('pin_value','electrical_type'): + for endpoint,fields in pin_metadata.get('comparisons',{}).items(): + l,r=fields.get('before',{}).get(key),fields.get('after',{}).get(key) + if l is not None and r is not None and l!=r: + issue('pin_text' if key=='pin_value' else 'pin_semantics','warning','引脚字段变化,需人工确认',left=l,right=r,field=key) + if 'export_identity' in requested: + diffs=[g.get('identity_tables',{}).get('keyin',{}).get('part_number_differences',[]) for g in (left,right)] + states['export_identity']='warning' if any(diffs) else 'equal' + if any(diffs):issue('export_identity','warning','原生身份表与有效料号存在差异',left=diffs[0],right=diffs[1]) + checks=[{'check_id':key,'state':states[key],'issues':[i['issue_id'] for i in issues if i['check_id']==key]} for key in sorted(CHECKS)] + return dict(rollup_results(checks,required_checks=plan['required_checks'],optional_checks=plan['optional_checks']), + checks=checks,issues=issues,scope='已核对换料规则' if declared else '未核对换料规则', + uncovered=['封装库内部引脚到焊盘映射','引脚级 Value(原生输出未证明)']) diff --git a/src/dx_productivity/trial_task_center/verification/runner.py b/src/dx_productivity/trial_task_center/verification/runner.py index caefcde..ae6324d 100644 --- a/src/dx_productivity/trial_task_center/verification/runner.py +++ b/src/dx_productivity/trial_task_center/verification/runner.py @@ -45,11 +45,9 @@ def run_attempt(service,attempt_id,*,stop_event): return {'published':False,'blocked':True} check_cancelled(stop_event) expected=service.artifacts.read(payload['expectation_ref'],'expectations') if payload['expectation_ref'] else None - comparison=native_netlist.compare_netlists(left,right,expected_changes=(expected or {}).get('changes')) - checks=[{'check_id':'inputs','state':'equal'}, - {'check_id':'coverage','state':'equal' if comparison['status']!='unavailable' else 'unknown'}] - result=dict(rollup_results(checks,required_checks=payload['check_plan']['required_checks']), - checks=checks,issues=[],before=left,after=right,attempt_state='succeeded',resource_state='released') + from .rules import evaluate + result=dict(evaluate(left,right,expectations=expected,check_plan=payload['check_plan']), + before=left,after=right,attempt_state='succeeded',resource_state='released') result.update(item_id=attempt['item_id'],input_version=attempt['input_version'],attempt_id=attempt_id, generation=attempt['generation'],input_digest=payload['payload_digest'],policy=payload['check_plan']) ref=service.artifacts.put('result',result) diff --git a/tests/v1_1/test_independent_verification_rules.py b/tests/v1_1/test_independent_verification_rules.py new file mode 100644 index 0000000..1a1c990 --- /dev/null +++ b/tests/v1_1/test_independent_verification_rules.py @@ -0,0 +1,86 @@ +import copy +import pytest +from dx_productivity.trial_task_center.verification.contracts import default_plan + + +def export(): + components={} + for uid,ref,pins in [('a','R12',{'loop':('1',['LOOP']),'GND':('2',['GND'])}), + ('b','U1',{'out':('3',['LOOP'])}),('c','C5',{'gnd':('2',['GND'])})]: + components[uid]={'refdes':ref,'attributes':{'Ref Designator':ref,'Part Number':'OLD','Value':'10K'}, + 'pins':{k:{'number':num,'nets':nets} for k,(num,nets) in pins.items()}} + return {'status':'success','complete':True,'graph':{'components':components,'nets':[ + {'name':'LOOP','endpoints':[['a','loop'],['b','out']]},{'name':'GND','endpoints':[['a','GND'],['c','gnd']]}]}} + + +def evaluate(left,right,**kwargs): + from dx_productivity.trial_task_center.verification.rules import evaluate + return evaluate(left,right,expectations=kwargs.pop('expectations',None),check_plan=kwargs.pop('check_plan',default_plan()),**kwargs) + + +def test_equal_graph_and_uid_change_preserve_refdes_identity(): + a=export();b=copy.deepcopy(a) + b['graph']['components']['new']=b['graph']['components'].pop('a') + for net in b['graph']['nets']: + for endpoint in net['endpoints']: + if endpoint[0]=='a':endpoint[0]='new' + assert evaluate(a,b)['verdict']=='CONSISTENT' + + +def test_swap_physical_pin_connections_is_hard_error(): + a=export();b=copy.deepcopy(a) + b['graph']['components']['a']['pins']['loop']['number']='2' + b['graph']['components']['a']['pins']['GND']['number']='1' + result=evaluate(a,b) + assert result['verdict']=='DIFFERENT' + assert any(i['check_id']=='connections' and i.get('pin_number')=='1' for i in result['issues']) + + +def test_pin_rename_is_warning_without_connection_error(): + a=export();b=copy.deepcopy(a) + b['graph']['components']['a']['pins']['outloop']=b['graph']['components']['a']['pins'].pop('loop') + b['graph']['nets'][0]['endpoints'][0][1]='outloop' + result=evaluate(a,b) + assert result['verdict']=='WARNING' + assert any(i['check_id']=='pin_text' for i in result['issues']) + assert not any(i['check_id']=='connections' for i in result['issues']) + + +@pytest.mark.parametrize('change',['disconnect','short','refdes','number','netname']) +def test_structural_changes_are_errors(change): + a=export();b=copy.deepcopy(a) + if change=='disconnect': + b['graph']['nets'][0]['endpoints'].pop(0);b['graph']['components']['a']['pins']['loop']['nets']=[] + if change=='short': + b['graph']['nets'][0]['endpoints']+=b['graph']['nets'][1]['endpoints'];b['graph']['nets'].pop() + for component in b['graph']['components'].values(): + for pin in component['pins'].values():pin['nets']=['LOOP'] + if change=='refdes':b['graph']['components']['a']['refdes']='R13';b['graph']['components']['a']['attributes']['Ref Designator']='R13' + if change=='number':b['graph']['components']['a']['pins']['loop']['number']='9' + if change=='netname': + b['graph']['nets'][0]['name']='RENAMED' + for uid,pin in [('a','loop'),('b','out')]:b['graph']['components'][uid]['pins'][pin]['nets']=['RENAMED'] + assert evaluate(a,b)['verdict']=='DIFFERENT' + + +def test_declared_values_exact_and_undeclared_changes_warn(): + a=export();b=copy.deepcopy(a);b['graph']['components']['a']['attributes']['Value']='NEW' + assert evaluate(a,b)['verdict']=='WARNING' + assert evaluate(a,b,expectations={'changes':{'a':{'Value':'NEW'}}})['verdict']=='CONSISTENT' + assert evaluate(a,b,expectations={'changes':{'a':{'Value':'WRONG'}}})['verdict']=='DIFFERENT' + assert evaluate(a,b,expectations={'changes':{}})['verdict']=='DIFFERENT' + + +def test_missing_required_mapping_never_passes_and_duplicate_ref_is_unknown(): + a=export();plan=default_plan();plan['excluded_checks']=[];plan['required_checks'].append('footprint_mapping') + assert evaluate(a,a,check_plan=plan)['verdict']=='INCOMPLETE' + b=copy.deepcopy(a);b['graph']['components']['c']['refdes']='R12' + assert evaluate(a,b)['verdict']=='INCOMPLETE' + + +def test_missing_pin_number_cannot_prove_equal_and_error_beats_unknown(): + a=export();b=copy.deepcopy(a);b['graph']['components']['a']['pins']['loop']['number']='' + assert evaluate(a,b)['verdict']=='INCOMPLETE' + b['graph']['components']['b']['attributes']['Value']='WRONG' + result=evaluate(a,b,expectations={'changes':{}}) + assert result['verdict']=='DIFFERENT' and result['unknown_checks'] -- 2.39.5 From deaf8c3ab41ef2b21d8566248d0e539e8afbaeee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=98=BF=E7=99=BD=E5=8F=94?= <11794527+absfan@user.noreply.gitee.com> Date: Tue, 17 Nov 2026 15:43:47 +0800 Subject: [PATCH 08/27] feat: expose proven pin metadata and unsupported mapping coverage --- .../2026-11-17-pin-metadata-capability.md | 7 +++ .../verification/pin_metadata.py | 58 +++++++++++++++++++ .../trial_task_center/verification/runner.py | 6 +- tests/v1_1/test_verification_pin_metadata.py | 20 +++++++ tools/probe_verification_pin_metadata.py | 16 +++++ 5 files changed, 106 insertions(+), 1 deletion(-) create mode 100644 docs/research/2026-11-17-pin-metadata-capability.md create mode 100644 src/dx_productivity/trial_task_center/verification/pin_metadata.py create mode 100644 tests/v1_1/test_verification_pin_metadata.py create mode 100644 tools/probe_verification_pin_metadata.py diff --git a/docs/research/2026-11-17-pin-metadata-capability.md b/docs/research/2026-11-17-pin-metadata-capability.md new file mode 100644 index 0000000..75f864c --- /dev/null +++ b/docs/research/2026-11-17-pin-metadata-capability.md @@ -0,0 +1,7 @@ +# 引脚字段读取范围 + +FREEFORM / FLAT BLOCKS 原生文本中的 `Pin 名称\tnum 编号\ttype 类型码` 可以与已解析图的实例、位号、物理脚号核对。适配器保留文件 SHA256 和行号,重复或无法绑定的字段不进入已证明清单。类型码按原文展示,不臆造类型语义。 + +自建格式夹具验证了逻辑名和电气类型码。引脚级 Value 尚未在该格式中证明,保持 unknown;器件 Value 不能代替它。确切库版本内部的引脚到焊盘映射尚未支持,保持未覆盖。没有进行客户工程真实字段验收。 + +探针:`python tools/probe_verification_pin_metadata.py <受管导出/netlist.json>`,只读已有输出,不调用 CAD、不修改工程。 diff --git a/src/dx_productivity/trial_task_center/verification/pin_metadata.py b/src/dx_productivity/trial_task_center/verification/pin_metadata.py new file mode 100644 index 0000000..6f539da --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/pin_metadata.py @@ -0,0 +1,58 @@ +"""Conservative native text adapter. Missing fields remain unknown.""" +from pathlib import Path +import re +from ..native_netlist import _hash, _instance_identity +from ..native_inventory import read_native_text +from .rules import component_key + + +def inspect_footprint_mapping(binding): + return {'state':'unknown','mapping':None,'reason':'未实现确切库版本的内部引脚到焊盘映射读取'} + + +def inspect_pin_metadata(export,*,evidence_root): + result={'pins':[],'uncovered':['引脚级 Value','库内引脚到焊盘映射']} + try: + path=Path(export.get('outputs',{})['effective']).resolve() + if not path.is_relative_to(Path(evidence_root).resolve()):raise ValueError('原始证据越界') + sha=_hash(path);lines=read_native_text(path).splitlines();records=[];record=None + for n,line in enumerate(lines,1): + if line.startswith(' Symbol '): + match=re.fullmatch(r' Symbol (.+?)\tref des ([^\t]*)\tpage ([^\t]*)',line) + record={'uid':match[1],'refdes':match[2],'page':match[3],'paths':[],'pins':[]} if match else None + if record:records.append(record) + elif record is not None: + if line.startswith('\tPath '):record['paths'].append(line[6:]) + elif line.startswith('\tPin '): + fields=line[5:].split('\t');values=dict(v.split(' ',1) for v in fields[1:] if ' ' in v) + record['pins'].append((fields[0],values,n)) + graph=export.get('graph',{}).get('components',{}) + candidates=[] + for record in records: + for scope in record['paths']: + uid=_instance_identity(record['uid'],scope);component=graph.get(uid) + if component is None or component.get('refdes')!=record['refdes']:continue + for name,values,n in record['pins']: + pin=component.get('pins',{}).get(name) + if not pin or not values.get('num') or pin.get('number')!=values['num']:continue + key=component_key(uid,component) + if key is None:continue + candidates.append({'endpoint':[*key,values['num']], + 'logical_name':{'value':name,'confidence':'proven'}, + 'pin_value':{'value':None,'confidence':'unknown'}, + 'electrical_type':{'value':values.get('type'),'confidence':'proven' if 'type' in values else 'unknown'}, + 'raw':{'path':str(path),'sha256':sha,'line':n,'page':record['page'] or None}}) + from collections import Counter + counts=Counter(tuple(p['endpoint']) for p in candidates) + result['pins']=[p for p in candidates if counts[tuple(p['endpoint'])]==1] + if _hash(path)!=sha:raise ValueError('原始证据在读取时变化') + except (OSError,ValueError,KeyError,TypeError) as error: + result.update(pins=[],reason=str(error)) + return result + + +def compare_metadata(before,after): + left={tuple(p['endpoint']):p for p in before['pins']};right={tuple(p['endpoint']):p for p in after['pins']} + return {'comparisons':{str(key):{phase:{name:row[name]['value'] for name in ('pin_value','electrical_type')} + for phase,row in (('before',left[key]),('after',right[key]))} + for key in left.keys()&right.keys()}} diff --git a/src/dx_productivity/trial_task_center/verification/runner.py b/src/dx_productivity/trial_task_center/verification/runner.py index ae6324d..2ffe284 100644 --- a/src/dx_productivity/trial_task_center/verification/runner.py +++ b/src/dx_productivity/trial_task_center/verification/runner.py @@ -46,8 +46,12 @@ def run_attempt(service,attempt_id,*,stop_event): check_cancelled(stop_event) expected=service.artifacts.read(payload['expectation_ref'],'expectations') if payload['expectation_ref'] else None from .rules import evaluate - result=dict(evaluate(left,right,expectations=expected,check_plan=payload['check_plan']), + from .pin_metadata import inspect_pin_metadata,compare_metadata + metadata={phase:inspect_pin_metadata(export,evidence_root=output) for phase,export in (('before',left),('after',right))} + result=dict(evaluate(left,right,expectations=expected,check_plan=payload['check_plan'], + pin_metadata=compare_metadata(metadata['before'],metadata['after'])), before=left,after=right,attempt_state='succeeded',resource_state='released') + result['pin_metadata']=metadata result.update(item_id=attempt['item_id'],input_version=attempt['input_version'],attempt_id=attempt_id, generation=attempt['generation'],input_digest=payload['payload_digest'],policy=payload['check_plan']) ref=service.artifacts.put('result',result) diff --git a/tests/v1_1/test_verification_pin_metadata.py b/tests/v1_1/test_verification_pin_metadata.py new file mode 100644 index 0000000..e7c719c --- /dev/null +++ b/tests/v1_1/test_verification_pin_metadata.py @@ -0,0 +1,20 @@ +from test_native_cli_netlist import graph + + +def test_native_pin_type_has_raw_proof_but_component_value_is_not_pin_value(tmp_path): + from dx_productivity.trial_task_center.verification.pin_metadata import inspect_pin_metadata + g=graph(tmp_path) + result=inspect_pin_metadata({'graph':g,'outputs':{'effective':str(tmp_path/'effective.txt')}},evidence_root=tmp_path) + pin=result['pins'][0] + assert pin['logical_name']['value']=='A' and pin['logical_name']['confidence']=='proven' + assert pin['electrical_type']['value']=='1' + assert pin['pin_value']['value'] is None and pin['pin_value']['confidence']=='unknown' + assert pin['raw']['sha256'] and pin['raw']['line']>0 + + +def test_missing_or_mismatched_raw_does_not_prove_metadata(tmp_path): + from dx_productivity.trial_task_center.verification.pin_metadata import inspect_pin_metadata,inspect_footprint_mapping + g=graph(tmp_path);g['components']['$1I1']['pins']['A']['number']='9' + result=inspect_pin_metadata({'graph':g,'outputs':{'effective':str(tmp_path/'effective.txt')}},evidence_root=tmp_path) + assert not result['pins'] + assert inspect_footprint_mapping({'evidence':None})['mapping'] is None diff --git a/tools/probe_verification_pin_metadata.py b/tools/probe_verification_pin_metadata.py new file mode 100644 index 0000000..4999ac2 --- /dev/null +++ b/tools/probe_verification_pin_metadata.py @@ -0,0 +1,16 @@ +"""Read an existing managed native export; never launch or write CAD.""" +import argparse +import json +from pathlib import Path +from dx_productivity.trial_task_center.verification.pin_metadata import inspect_pin_metadata + + +def main(): + parser=argparse.ArgumentParser();parser.add_argument('export',type=Path) + args=parser.parse_args() + result=inspect_pin_metadata(json.loads(args.export.read_text(encoding='utf-8')),evidence_root=args.export.parent) + print(json.dumps(result,ensure_ascii=False,indent=2)) + return 0 if result['pins'] else 1 + + +if __name__=='__main__':raise SystemExit(main()) -- 2.39.5 From f25dd228fd0212133ea10cc43bc12f3676e7009c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=98=BF=E7=99=BD=E5=8F=94?= <11794527+absfan@user.noreply.gitee.com> Date: Tue, 17 Nov 2026 15:45:16 +0800 Subject: [PATCH 09/27] feat: build traceable pin and network comparison evidence --- .../verification/evidence.py | 42 +++++++++++++++++++ .../trial_task_center/verification/runner.py | 10 +++++ tests/v1_1/test_verification_evidence.py | 29 +++++++++++++ 3 files changed, 81 insertions(+) create mode 100644 src/dx_productivity/trial_task_center/verification/evidence.py create mode 100644 tests/v1_1/test_verification_evidence.py diff --git a/src/dx_productivity/trial_task_center/verification/evidence.py b/src/dx_productivity/trial_task_center/verification/evidence.py new file mode 100644 index 0000000..a66ab64 --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/evidence.py @@ -0,0 +1,42 @@ +"""One immutable fact model for diagrams, tables and reports.""" +import copy +import re +from .contracts import digest,fail +from .rules import physical_view + + +def pin_sort(value): + return tuple((0,int(part)) if part.isdigit() else (1,part) for part in re.split(r'(\d+)',str(value))) + + +def build_evidence(before_graph,after_graph,issues,*,binding): + views=[];limitations=[] + for graph in (before_graph,after_graph): + try:views.append(physical_view(graph)) + except (ValueError,TypeError,KeyError) as error:views.append({});limitations.append(str(error)) + left,right=views;pins=[] + for endpoint in sorted(left.keys()|right.keys(),key=lambda e:(e[:2],pin_sort(e[2]))): + l,r=left.get(endpoint),right.get(endpoint) + associated=[i['issue_id'] for i in issues if i.get('instance_path')==endpoint[0] + and i.get('refdes')==endpoint[1] and (i.get('pin_number') in (None,endpoint[2]))] + connection_changed=any(i['issue_id'] in associated and i['check_id'] in {'connections','physical_pins'} and i['state']=='error' for i in issues) + pins.append({'endpoint':list(endpoint),'before':l,'after':r,'issue_ids':associated, + 'connection_changed':connection_changed, + 'text_changed':bool(l and r and l['logical_name']!=r['logical_name'])}) + result={'schema_version':1,'binding':copy.deepcopy(binding),'issues':copy.deepcopy(list(issues)), + 'pins':pins,'page':None,'label':'由网表生成','limitations':limitations+['未覆盖:封装库内部映射']} + result['digest']=digest(result) + return result + + +def verify_evidence(evidence): + if evidence.get('digest')!=digest({k:v for k,v in evidence.items() if k!='digest'}): + fail('证据包摘要不符。','verification_evidence') + + +def connection_view(evidence,issue_id): + verify_evidence(evidence) + issue=next((i for i in evidence['issues'] if i['issue_id']==issue_id),None) + if issue is None:fail('问题记录不存在。') + return {'issue':issue,'pins':[p for p in evidence['pins'] if p['endpoint'][:2]==[issue.get('instance_path'),issue.get('refdes')]], + 'page':evidence['page'],'binding':evidence['binding'],'label':evidence['label']} diff --git a/src/dx_productivity/trial_task_center/verification/runner.py b/src/dx_productivity/trial_task_center/verification/runner.py index 2ffe284..886a558 100644 --- a/src/dx_productivity/trial_task_center/verification/runner.py +++ b/src/dx_productivity/trial_task_center/verification/runner.py @@ -54,6 +54,16 @@ def run_attempt(service,attempt_id,*,stop_event): result['pin_metadata']=metadata result.update(item_id=attempt['item_id'],input_version=attempt['input_version'],attempt_id=attempt_id, generation=attempt['generation'],input_digest=payload['payload_digest'],policy=payload['check_plan']) + from .evidence import build_evidence + raw=[] + for phase,export in (('before',left),('after',right)): + for kind,path in export.get('outputs',{}).items(): + file=Path(path).resolve() + if not file.is_relative_to(output.resolve()):raise ValueError('导出证据越界') + raw.append({'artifact_id':phase+':'+kind,'path':str(file),'sha256':native_netlist._hash(file)}) + result['evidence']=build_evidence(left.get('graph',{}),right.get('graph',{}),result['issues'], + binding={'attempt_id':attempt_id,'input_version':attempt['input_version'], + 'input_digest':payload['payload_digest'],'raw':raw}) ref=service.artifacts.put('result',result) result['result_ref']=ref check_cancelled(stop_event) diff --git a/tests/v1_1/test_verification_evidence.py b/tests/v1_1/test_verification_evidence.py new file mode 100644 index 0000000..cbd35ef --- /dev/null +++ b/tests/v1_1/test_verification_evidence.py @@ -0,0 +1,29 @@ +import copy +from test_independent_verification_rules import export,evaluate + + +def test_swap_diagram_uses_fixed_pin_order_and_same_connection_facts(): + from dx_productivity.trial_task_center.verification.evidence import build_evidence,connection_view + a=export();b=copy.deepcopy(a) + b['graph']['components']['a']['pins']['loop']['number']='2' + b['graph']['components']['a']['pins']['GND']['number']='1' + result=evaluate(a,b) + evidence=build_evidence(a['graph'],b['graph'],result['issues'],binding={'attempt_id':'attempt','input_version':1}) + issue=next(i for i in result['issues'] if i['check_id']=='connections' and i['refdes']=='R12') + view=connection_view(evidence,issue['issue_id']) + assert [p['endpoint'][2] for p in view['pins']]==['1','2'] + assert all(p['connection_changed'] for p in view['pins']) + assert view['pins'][0]['before']['nets'][0]['name']=='LOOP' + assert view['pins'][0]['after']['nets'][0]['name']=='GND' + assert view['page'] is None and evidence['digest'] + + +def test_pure_rename_has_no_false_red_connection(): + from dx_productivity.trial_task_center.verification.evidence import build_evidence + a=export();b=copy.deepcopy(a) + b['graph']['components']['a']['pins']['outloop']=b['graph']['components']['a']['pins'].pop('loop') + b['graph']['nets'][0]['endpoints'][0][1]='outloop' + result=evaluate(a,b) + evidence=build_evidence(a['graph'],b['graph'],result['issues'],binding={}) + assert any(p['text_changed'] for p in evidence['pins']) + assert not any(p['connection_changed'] for p in evidence['pins']) -- 2.39.5 From e6e9b6906dce10138caf60d8d250e7e42cf7085a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=98=BF=E7=99=BD=E5=8F=94?= <11794527+absfan@user.noreply.gitee.com> Date: Tue, 17 Nov 2026 15:52:25 +0800 Subject: [PATCH 10/27] feat: add the independent verification workspace and evidence inspector --- .../trial_task_center/ui/icons.py | 1 + .../trial_task_center/ui/main_window.py | 14 +- .../ui/verification_controller.py | 36 ++++ .../ui/verification_inspector.py | 107 +++++++++++ .../ui/verification_workspace.py | 172 ++++++++++++++++++ tests/ui/test_verification_inspector.py | 16 ++ tests/ui/test_verification_workspace.py | 26 +++ 7 files changed, 370 insertions(+), 2 deletions(-) create mode 100644 src/dx_productivity/trial_task_center/ui/verification_controller.py create mode 100644 src/dx_productivity/trial_task_center/ui/verification_inspector.py create mode 100644 src/dx_productivity/trial_task_center/ui/verification_workspace.py create mode 100644 tests/ui/test_verification_inspector.py create mode 100644 tests/ui/test_verification_workspace.py diff --git a/src/dx_productivity/trial_task_center/ui/icons.py b/src/dx_productivity/trial_task_center/ui/icons.py index 90f14c2..38546b9 100644 --- a/src/dx_productivity/trial_task_center/ui/icons.py +++ b/src/dx_productivity/trial_task_center/ui/icons.py @@ -30,6 +30,7 @@ def icon(name: str, primary: bool = False) -> QIcon: BUTTON_ICONS = { 'task_center_navigation': 'grid', 'dsh_navigation': 'chat', 'history_navigation': 'clock', + 'verification_navigation': 'check', 'verificationNew': 'plus', 'newTaskButton': 'plus', 'editTaskButton': 'sliders', 'deleteTaskButton': 'trash', 'selectAllTasks': 'check', 'clearTaskSelection': 'close', 'restoreTaskButton': 'refresh', 'taskRecycleBin': 'trash', diff --git a/src/dx_productivity/trial_task_center/ui/main_window.py b/src/dx_productivity/trial_task_center/ui/main_window.py index 1053c4d..66f1fc0 100644 --- a/src/dx_productivity/trial_task_center/ui/main_window.py +++ b/src/dx_productivity/trial_task_center/ui/main_window.py @@ -60,6 +60,8 @@ class TrialTaskCenterWindow(MaterialMainWindow): self.dsh_action = QAction('DSH助手', self) self.dsh_action.setShortcut('Ctrl+Shift+D') self.dsh_action.triggered.connect(self._open_dsh) + self.verification_action = QAction('工程校验', self) + self.verification_action.triggered.connect(lambda: self.content_stack.setCurrentWidget(self.verification_panel)) self._navigation_actions = QActionGroup(self) self._navigation_actions.setExclusive(True) navigation = QWidget(objectName='toolNavigation') @@ -70,7 +72,8 @@ class TrialTaskCenterWindow(MaterialMainWindow): navigation_layout.addWidget(brand) navigation_layout.addSpacing(24) for name, action in (('task_center_navigation', self.task_center_action), - ('history_navigation', self.history_action), ('dsh_navigation', self.dsh_action)): + ('history_navigation', self.history_action), ('dsh_navigation', self.dsh_action), + ('verification_navigation', self.verification_action)): action.setCheckable(True) self._navigation_actions.addAction(action) self.addAction(action) @@ -292,14 +295,20 @@ class TrialTaskCenterWindow(MaterialMainWindow): self.history_panel = OperationHistoryPage(self.service, self) self.history_panel.busy_changed.connect(self._history_activity_changed) self.content_stack.addWidget(self.history_panel) + from .verification_workspace import VerificationWorkspace + self.verification_panel = VerificationWorkspace(self.service, self) + self.content_stack.addWidget(self.verification_panel) self.content_stack.currentChanged.connect(self._workspace_changed) self.setCentralWidget(self.content_stack) self._reset_layout() def _workspace_changed(self, index): history = self.content_stack.widget(index) is self.history_panel - (self.task_center_action if index == 0 else self.history_action if history else self.dsh_action).setChecked(True) + verification = self.content_stack.widget(index) is self.verification_panel + action = self.task_center_action if index == 0 else self.history_action if history else self.verification_action if verification else self.dsh_action + action.setChecked(True) self.history_panel.set_active(history) + self.verification_panel.set_active(verification) def _history_activity_changed(self): self._update_gates() @@ -408,6 +417,7 @@ class TrialTaskCenterWindow(MaterialMainWindow): self._dsh_status.close() self._dsh_stall_timer.stop() self.history_panel.shutdown() + self.verification_panel.shutdown() if self._dsh_operations: self._dsh_operations.close() self._context_query.close() diff --git a/src/dx_productivity/trial_task_center/ui/verification_controller.py b/src/dx_productivity/trial_task_center/ui/verification_controller.py new file mode 100644 index 0000000..6c080ed --- /dev/null +++ b/src/dx_productivity/trial_task_center/ui/verification_controller.py @@ -0,0 +1,36 @@ +"""Asynchronous verification reads; each selection owns its own query generation.""" +from PySide6.QtCore import QObject,QThreadPool,Signal,Slot +from .queries import LatestQuery +from .workers import ServiceWorker + + +class VerificationController(QObject): + changed=Signal() + failed=Signal(object) + def __init__(self,service,parent=None): + super().__init__(parent);self.service=service;self.task_id=None;self.item_id=None + self.tasks_query=LatestQuery(self);self.task_query=LatestQuery(self);self.item_query=LatestQuery(self) + self.workers={};self.closed=False + for query in (self.tasks_query,self.task_query,self.item_query):query.settled.connect(self.changed) + + @property + def busy(self): + return bool(self.workers) or any(q.busy for q in (self.tasks_query,self.task_query,self.item_query)) or getattr(self.service,'busy',False) + + def command(self,action,received): + if self.closed:return + worker=ServiceWorker(action);self.workers[worker.signals]=(worker,received) + worker.signals.succeeded.connect(self._received);worker.signals.failed.connect(self.failed) + worker.signals.finished.connect(self._finished);QThreadPool.globalInstance().start(worker);self.changed.emit() + + @Slot(object) + def _received(self,result): + entry=self.workers.get(self.sender()) + if entry and not self.closed:entry[1](result) + + @Slot() + def _finished(self):self.workers.pop(self.sender(),None);self.changed.emit() + + def close(self): + self.closed=True + for q in (self.tasks_query,self.task_query,self.item_query):q.close() diff --git a/src/dx_productivity/trial_task_center/ui/verification_inspector.py b/src/dx_productivity/trial_task_center/ui/verification_inspector.py new file mode 100644 index 0000000..0583856 --- /dev/null +++ b/src/dx_productivity/trial_task_center/ui/verification_inspector.py @@ -0,0 +1,107 @@ +"""Deterministic before/after netlist drawing and matching facts.""" +import json +from PySide6.QtCore import QRectF,Qt,Signal +from PySide6.QtGui import QColor,QPainter,QPen +from PySide6.QtWidgets import (QWidget,QLabel,QVBoxLayout,QHBoxLayout,QComboBox,QTableWidget, + QTableWidgetItem,QHeaderView,QTabWidget,QScrollArea,QPlainTextEdit,QPushButton) +from ..verification.evidence import verify_evidence + + +def pin_text(pin): + if pin is None:return '不存在/未覆盖' + if not pin['nets']:return '明确未连接' + return '\n'.join(n['name']+' · '+', '.join(f'{e[1]}.{e[2]}' for e in n['endpoints'] if e!=[None]) for n in pin['nets']) + + +class ConnectionDiagram(QWidget): + def __init__(self,parent=None): + super().__init__(parent);self.pins=[];self.setMinimumSize(320,220) + + def set_pins(self,pins): + self.pins=pins;self.setMinimumHeight(max(220,100+len(pins)*100));self.update() + + def paintEvent(self,event): + painter=QPainter(self);painter.setRenderHint(QPainter.RenderHint.Antialiasing) + painter.fillRect(self.rect(),QColor('#ffffff'));w=self.width()/2 + for column,phase,title in ((0,'before','修改前'),(1,'after','修改后')): + x=column*w+12 + painter.setPen(QColor('#34445b'));painter.drawText(QRectF(x,8,w-24,26),Qt.AlignmentFlag.AlignLeft,title) + painter.setPen(QPen(QColor('#dfe6ef'),1));painter.drawRoundedRect(QRectF(x,40,w-24,self.height()-55),9,9) + for n,row in enumerate(self.pins): + y=64+n*100;pin=row[phase] + color=QColor('#bf3f4a' if row['connection_changed'] else '#b37925' if row['text_changed'] else '#438a89') + painter.setPen(color);painter.drawText(QRectF(x+12,y,w-46,24),Qt.AlignmentFlag.AlignLeft, + f"脚 {row['endpoint'][2]} {pin['logical_name'] if pin else '未覆盖'}") + painter.drawLine(int(x+18),int(y+37),int(x+40),int(y+37)) + painter.setPen(QColor('#516078')) + font=painter.font();font.setPointSizeF(8.5);painter.setFont(font) + painter.drawText(QRectF(x+44,y+24,w-78,64),Qt.TextFlag.TextWordWrap,pin_text(pin)) + painter.end() + + +class VerificationInspector(QWidget): + open_raw=Signal(str) + select_version=Signal(int) + def __init__(self,parent=None): + super().__init__(parent);self.evidence=None + layout=QVBoxLayout(self);layout.setContentsMargins(12,8,12,8) + self.heading=QLabel('选择工程查看证据',objectName='projectTitle');layout.addWidget(self.heading) + self.coverage=QLabel('未覆盖:封装库内部映射');self.coverage.setWordWrap(True);layout.addWidget(self.coverage) + row=QHBoxLayout();self.components=QComboBox();self.components.setMinimumWidth(100) + self.versions=QComboBox();self.versions.setToolTip('查看历史输入版本,不改变当前输入') + row.addWidget(self.components,1);row.addWidget(self.versions);layout.addLayout(row) + self.issues=QComboBox();layout.addWidget(self.issues) + self.tabs=QTabWidget();layout.addWidget(self.tabs,1) + self.diagram=ConnectionDiagram();scroll=QScrollArea();scroll.setWidgetResizable(True);scroll.setWidget(self.diagram) + self.tabs.addTab(scroll,'前后接线图') + self.pin_table=QTableWidget(0,5);self.pin_table.setHorizontalHeaderLabels(['脚号','前名称','后名称','前连接','后连接']) + self.pin_table.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers) + self.pin_table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents) + self.tabs.addTab(self.pin_table,'逐脚事实') + self.facts=QPlainTextEdit();self.facts.setReadOnly(True);self.tabs.addTab(self.facts,'检查与范围') + self.raw=QComboBox();self.raw_button=QPushButton('打开原始证据') + rawrow=QHBoxLayout();rawrow.addWidget(self.raw,1);rawrow.addWidget(self.raw_button);layout.addLayout(rawrow) + self.raw_button.clicked.connect(lambda:self.open_raw.emit(self.raw.currentData()) if self.raw.currentData() else None) + self.components.currentIndexChanged.connect(self._component) + self.issues.currentIndexChanged.connect(self._issue) + self.versions.activated.connect(lambda _:self.select_version.emit(self.versions.currentData())) + + def set_record(self,record): + self.versions.blockSignals(True);self.versions.clear() + for version in sorted({record['current_version'],*(h['input_version'] for h in record['history'])},reverse=True): + self.versions.addItem(f'输入 v{version}',version) + self.versions.setCurrentIndex(self.versions.findData(record['input_version']));self.versions.blockSignals(False) + result=((record.get('attempt') or {}).get('result') or {}) + self.set_evidence(result.get('evidence')) + self.heading.setText(record['display_name']+' · '+{'CONSISTENT':'一致','WARNING':'需关注','DIFFERENT':'异常','INCOMPLETE':'无法完整校验'}.get(result.get('verdict'),'待校验')) + self.facts.setPlainText(json.dumps({'范围':result.get('scope',record['scope']),'检查':result.get('checks',[]), + '问题':result.get('issues',[]),'执行原因':result.get('reason') or record.get('unavailable_reason'), + '输入摘要':record['payload']['payload_digest'],'尝试':record.get('attempt_id')},ensure_ascii=False,indent=2)) + + def set_evidence(self,evidence): + if evidence:verify_evidence(evidence) + self.evidence=evidence;self.components.blockSignals(True);self.components.clear();self.issues.blockSignals(True);self.issues.clear();self.raw.clear() + if evidence: + for key in sorted({tuple(p['endpoint'][:2]) for p in evidence['pins']}):self.components.addItem(f'{key[1]} · {key[0]}',key) + self.issues.addItem('全部问题',None) + for issue in evidence['issues']:self.issues.addItem(f"{issue.get('refdes','工程')} · {issue['reason']}",issue) + for raw in evidence['binding'].get('raw',[]):self.raw.addItem(raw['artifact_id'],raw['artifact_id']) + self.coverage.setText('由网表生成 · 图页未定位\n未覆盖:封装库内部映射、引脚级 Value') + self.components.blockSignals(False);self.issues.blockSignals(False);self._component() + + def _issue(self): + issue=self.issues.currentData() + if issue: + key=(issue.get('instance_path'),issue.get('refdes')) + index=self.components.findData(key) + if index>=0:self.components.setCurrentIndex(index) + + def _component(self): + key=self.components.currentData() + pins=[p for p in (self.evidence or {}).get('pins',[]) if tuple(p['endpoint'][:2])==key] + self.diagram.set_pins(pins);self.pin_table.setRowCount(len(pins)) + for n,row in enumerate(pins): + l,r=row['before'],row['after'] + for col,value in enumerate((row['endpoint'][2],l['logical_name'] if l else '未知',r['logical_name'] if r else '未知',pin_text(l),pin_text(r))): + self.pin_table.setItem(n,col,QTableWidgetItem(value)) + self.pin_table.resizeRowsToContents() diff --git a/src/dx_productivity/trial_task_center/ui/verification_workspace.py b/src/dx_productivity/trial_task_center/ui/verification_workspace.py new file mode 100644 index 0000000..222ac1d --- /dev/null +++ b/src/dx_productivity/trial_task_center/ui/verification_workspace.py @@ -0,0 +1,172 @@ +"""The fourth workspace: independently creatable tasks and continuous handoff.""" +from threading import Event +from uuid import uuid4 +from PySide6.QtCore import Qt,QTimer,Signal,QSignalBlocker +from PySide6.QtWidgets import (QWidget,QVBoxLayout,QHBoxLayout,QLabel,QPushButton,QListWidget,QListWidgetItem, + QTableWidget,QTableWidgetItem,QSplitter,QLineEdit,QComboBox,QInputDialog,QFileDialog,QHeaderView) +from .verification_controller import VerificationController +from .verification_inspector import VerificationInspector + +LABELS={'consistent':'一致','warning':'需关注','different':'异常','unavailable':'无法校验', + 'waiting':'待校验','running':'校验中','stopped':'已停止','interrupted':'已中断'} + + +class VerificationWorkspace(QWidget): + busy_changed=Signal() + def __init__(self,service,parent=None): + super().__init__(parent);self.service=service.verification;self.controller=VerificationController(self.service,self) + self._active=False;self._closed=False;self._run_id=None;self._rows=[];self._cursor=None;self._intake_stop=Event() + layout=QVBoxLayout(self);layout.setContentsMargins(16,12,16,12) + head=QHBoxLayout();self.title=QLabel('工程校验',objectName='verificationTitle');head.addWidget(self.title);head.addStretch() + self.new_button=QPushButton('新建校验',objectName='verificationNew');self.import_button=QPushButton('添加工程对') + head.addWidget(self.import_button);head.addWidget(self.new_button);layout.addLayout(head) + description=QLabel('替换完成后接续核对,也可随时添加两份工程独立校验。');description.setWordWrap(True);layout.addWidget(description) + self.splitter=QSplitter();layout.addWidget(self.splitter,1) + left=QWidget();ll=QVBoxLayout(left);ll.setContentsMargins(0,0,8,0);ll.addWidget(QLabel('校验任务')) + self.tasks=QListWidget();ll.addWidget(self.tasks,1) + self.state_filter=QComboBox();self.state_filter.addItem('全部工程','') + for key,value in LABELS.items():self.state_filter.addItem(value,key) + ll.addWidget(self.state_filter);self.splitter.addWidget(left) + middle=QWidget();ml=QVBoxLayout(middle);ml.setContentsMargins(4,0,4,0) + self.search=QLineEdit();self.search.setPlaceholderText('搜索工程、位号、料号');self.search.setClearButtonEnabled(True);ml.addWidget(self.search) + controls=QHBoxLayout();self.start_button=QPushButton('开始全部');self.selected_button=QPushButton('校验所选');self.stop_button=QPushButton('停止') + for button in (self.start_button,self.selected_button,self.stop_button):controls.addWidget(button) + ml.addLayout(controls) + self.table=QTableWidget(0,4);self.table.setHorizontalHeaderLabels(['工程','版本','结果','范围']) + self.table.setSelectionBehavior(QTableWidget.SelectionBehavior.SelectRows);self.table.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers) + self.table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Stretch);ml.addWidget(self.table,1) + bottom=QHBoxLayout();self.more_button=QPushButton('加载更多');self.rerun_button=QPushButton('重校验');self.export_button=QPushButton('导出报告') + for button in (self.more_button,self.rerun_button,self.export_button):bottom.addWidget(button) + ml.addLayout(bottom);self.splitter.addWidget(middle) + self.inspector=VerificationInspector();self.splitter.addWidget(self.inspector);self.splitter.setSizes([180,430,570]) + self.footer=QLabel('新建一个校验任务开始。');self.footer.setWordWrap(True);layout.addWidget(self.footer) + self.notice=QLabel('');self.notice.setWordWrap(True);layout.addWidget(self.notice) + self.new_button.clicked.connect(self._new);self.import_button.clicked.connect(self._import) + self.tasks.currentItemChanged.connect(self._task_selected);self.table.itemSelectionChanged.connect(self._item_selected) + self.state_filter.currentIndexChanged.connect(self.refresh_task);self.search.textChanged.connect(self._search_changed) + self.more_button.clicked.connect(lambda:self.refresh_task(append=True));self.start_button.clicked.connect(lambda:self._start(False)) + self.selected_button.clicked.connect(lambda:self._start(True));self.stop_button.clicked.connect(self._stop) + self.rerun_button.clicked.connect(self._rerun);self.export_button.clicked.connect(self._export) + self.inspector.open_raw.connect(self._open_raw);self.inspector.select_version.connect(self._version) + self.controller.failed.connect(self._error);self.controller.changed.connect(self._gates) + self._timer=QTimer(self);self._timer.setInterval(1500);self._timer.timeout.connect(self.refresh) + self._debounce=QTimer(self);self._debounce.setSingleShot(True);self._debounce.setInterval(250);self._debounce.timeout.connect(self.refresh_task) + self._gates() + + @property + def busy(self):return self.controller.busy + + def _error(self,error):self.notice.setText(str(error)) + + def _gates(self): + has=bool(self.controller.task_id);item=bool(self.controller.item_id) + self.import_button.setEnabled(has);self.start_button.setEnabled(has);self.selected_button.setEnabled(has and item) + self.rerun_button.setEnabled(item);self.export_button.setEnabled(has) + self.stop_button.setEnabled(bool(self._run_id) or getattr(self.service,'busy',False)) + self.busy_changed.emit() + + def set_active(self,active): + self._active=active + if active: + self._timer.start();self.controller.command(self.service.reconcile_deliveries,lambda _:self.refresh()) + else:self._timer.stop() + + def refresh(self): + if self._closed:return + self.controller.tasks_query.request(lambda control:self.service.list_tasks(read_control=control),self._tasks_received,self._error,cancellable=True) + if self.controller.task_id:self.refresh_task() + self._gates() + + def _tasks_received(self,result): + with QSignalBlocker(self.tasks): + self.tasks.clear() + for row in result['tasks']: + item=QListWidgetItem(row['name']+f" {row['summary']['processed']}/{row['summary']['total']}") + item.setData(Qt.ItemDataRole.UserRole,row['task_id']);self.tasks.addItem(item) + if row['task_id']==self.controller.task_id:self.tasks.setCurrentItem(item) + if not self.controller.task_id and self.tasks.count():self.open_task(self.tasks.item(0).data(Qt.ItemDataRole.UserRole)) + + def open_task(self,task_id,item_id=None): + self.controller.task_id=task_id;self.controller.item_id=item_id;self._cursor=None + self.controller.item_query.invalidate();self.inspector.set_evidence(None);self.refresh();self._gates() + + def _task_selected(self,item,previous): + if item:self.open_task(item.data(Qt.ItemDataRole.UserRole)) + + def _search_changed(self):self._debounce.start() + + def refresh_task(self,*_,append=False): + task=self.controller.task_id + if not task or self._closed:return + cursor=self._cursor if append else None + self.controller.task_query.request(lambda control:self.service.read_task(task,state=self.state_filter.currentData(), + query=self.search.text(),cursor=cursor,read_control=control),lambda result:self._task_received(result,append),self._error,cancellable=True) + + def _task_received(self,result,append): + self._rows=self._rows+result['items'] if append else result['items'];self._cursor=result['cursor'] + selected=self.controller.item_id + with QSignalBlocker(self.table): + self.table.setRowCount(len(self._rows)) + for n,row in enumerate(self._rows): + for col,value in enumerate((row['display_name'],str(row['input_version']),LABELS[row['status']],row['scope'])): + cell=QTableWidgetItem(value);cell.setData(Qt.ItemDataRole.UserRole,row['item_id']);self.table.setItem(n,col,cell) + if row['item_id']==selected:self.table.selectRow(n) + self.more_button.setEnabled(bool(self._cursor)) + s=result['summary'];self.footer.setText(f"已处理 {s['processed']}/{s['total']} · 一致 {s['consistent']} · 关注 {s['warning']} · 异常 {s['different']} · 无法校验 {s['unavailable']} · 待校验 {s['waiting']}") + if selected:self._load_item(selected) + self._gates() + + def _item_selected(self): + row=self.table.currentRow() + if 0<=row=1 + assert '未覆盖' in widget.coverage.text() + assert widget.diagram.pins==[p for p in evidence['pins'] if p['endpoint'][:2]==widget.diagram.pins[0]['endpoint'][:2]] diff --git a/tests/ui/test_verification_workspace.py b/tests/ui/test_verification_workspace.py new file mode 100644 index 0000000..0b1ade8 --- /dev/null +++ b/tests/ui/test_verification_workspace.py @@ -0,0 +1,26 @@ +from PySide6.QtCore import Qt + + +def test_fourth_navigation_is_independent_and_does_not_open_dsh(ui,qtbot): + window=ui.window + window.verification_action.trigger() + qtbot.waitUntil(lambda:window.content_stack.currentWidget() is window.verification_panel) + page=window.verification_panel + assert window.verification_action.isChecked() and not window.dsh_action.isChecked() + assert window._dsh_view is None and page.new_button.isEnabled() + task=ui.service.verification.create_task('独立校验',request_id='one')['task_id'] + page.open_task(task) + qtbot.waitUntil(lambda:page.controller.task_id==task and not page.controller.task_query.busy) + assert page.new_button.isEnabled() + assert page.table.rowCount()==0 + assert '来源' not in page.findChild(type(page.title),'verificationTitle').text() + + +def test_page_keeps_selected_task_when_refreshed(ui,qtbot): + page=ui.window.verification_panel + task=ui.service.verification.create_task('任务',request_id='one')['task_id'] + page.open_task(task);page.set_active(True) + qtbot.waitUntil(lambda:page.tasks.count()==1) + page.refresh() + qtbot.waitUntil(lambda:not page.controller.tasks_query.busy) + assert page.controller.task_id==task -- 2.39.5 From b9712ed65100b192b4edfe0352721162c4b13ccb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=98=BF=E7=99=BD=E5=8F=94?= <11794527+absfan@user.noreply.gitee.com> Date: Tue, 17 Nov 2026 15:59:28 +0800 Subject: [PATCH 11/27] feat: control and recover independent verification attempts --- .../trial_task_center/ui/main_window.py | 6 + .../ui/verification_workspace.py | 2 +- .../trial_task_center/verification/control.py | 135 ++++++++++++++++++ .../trial_task_center/verification/runner.py | 8 ++ .../trial_task_center/verification/service.py | 22 +++ tests/ui/test_verification_control.py | 8 ++ tests/v1_1/test_verification_control.py | 59 ++++++++ 7 files changed, 239 insertions(+), 1 deletion(-) create mode 100644 src/dx_productivity/trial_task_center/verification/control.py create mode 100644 tests/ui/test_verification_control.py create mode 100644 tests/v1_1/test_verification_control.py diff --git a/src/dx_productivity/trial_task_center/ui/main_window.py b/src/dx_productivity/trial_task_center/ui/main_window.py index 66f1fc0..aeaf736 100644 --- a/src/dx_productivity/trial_task_center/ui/main_window.py +++ b/src/dx_productivity/trial_task_center/ui/main_window.py @@ -358,6 +358,12 @@ class TrialTaskCenterWindow(MaterialMainWindow): if self._close_saving: event.ignore() return + if self.verification_panel.busy: + self._close_pending = True + self.verification_panel.begin_shutdown() + event.ignore() + QTimer.singleShot(100, self.close) + return if self._workers or self.history_panel._worker: self._close_pending = True if self._dsh_automation and getattr(self._dsh_automation, '_owns_execution_lane', False): diff --git a/src/dx_productivity/trial_task_center/ui/verification_workspace.py b/src/dx_productivity/trial_task_center/ui/verification_workspace.py index 222ac1d..7181a54 100644 --- a/src/dx_productivity/trial_task_center/ui/verification_workspace.py +++ b/src/dx_productivity/trial_task_center/ui/verification_workspace.py @@ -68,7 +68,7 @@ class VerificationWorkspace(QWidget): def set_active(self,active): self._active=active if active: - self._timer.start();self.controller.command(self.service.reconcile_deliveries,lambda _:self.refresh()) + self._timer.start();self.controller.command(self.service.initialize,lambda _:self.refresh()) else:self._timer.stop() def refresh(self): diff --git a/src/dx_productivity/trial_task_center/verification/control.py b/src/dx_productivity/trial_task_center/verification/control.py new file mode 100644 index 0000000..f3a9017 --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/control.py @@ -0,0 +1,135 @@ +"""Frozen run membership and cooperative cancellation for the verification domain.""" +import json +from threading import Event,Thread,RLock +from uuid import uuid4 +from .contracts import ACTIVE,digest,fail +from .store import encode,now + + +class VerificationControl: + def __init__(self,service): + self.service=service;self.repo=service.repo;self.lock=RLock();self.events={};self.thread=None;self.closing=False + + @property + def busy(self): + with self.lock:return bool(self.thread and self.thread.is_alive()) + + def start(self,task_id,*,selection,request_id): + if self.closing:fail('校验执行器正在安全关闭。') + body=[task_id,selection] + with self.repo.store.transaction(): + old=self.repo._request('start',request_id,body) + if old is not None:return old + self.repo.task(task_id) + active=self.repo.connection.execute("SELECT * FROM verification_runs WHERE task_id=? AND state IN ('queued','running','stopping') ORDER BY created LIMIT 1",(task_id,)).fetchone() + if active: + result={'run_id':active['run_id'],'members':json.loads(active['members_json'])} + else: + rows=self.service.queries._rows(task_id) + wanted=set(tuple(v) for v in selection) if selection is not None else None + members=[];run_id=uuid4().hex + for row in rows: + identity=(row['item_id'],row['input_version']) + if wanted is not None and identity not in wanted:continue + if not row['can_start']:continue + # Start all only processes waiting/interrupted items; explicit selection permits recheck. + if wanted is None and row['status'] not in {'waiting','interrupted'}:continue + attempt=self.repo.create_attempt(*identity,request_id='run-attempt:'+run_id+':'+row['item_id'],run_id=run_id) + members.append({'item_id':identity[0],'input_version':identity[1],'attempt_id':attempt['attempt_id']}) + if wanted and wanted-{(m['item_id'],m['input_version']) for m in members}:fail('所选版本已变化或正在执行,请刷新。') + self.repo.connection.execute('INSERT INTO verification_runs(run_id,task_id,members_json,state,created) VALUES (?,?,?,?,?)', + (run_id,task_id,encode(members),'queued' if members else 'completed',now())) + result={'run_id':run_id,'members':members} + self.repo._remember('start',request_id,body,result) + self.wake() + return result + + def wake(self): + with self.lock: + if not self.closing and not self.busy: + self.thread=Thread(target=self._dispatch,name='verification-runner',daemon=True);self.thread.start() + + def stop(self,run_id,*,request_id): + with self.repo.store.transaction(): + old=self.repo._request('stop',request_id,run_id) + if old is not None:return old + run=self.repo._one('verification_runs','run_id',run_id) + self.repo.connection.execute("UPDATE verification_runs SET stop_requested=1,state=CASE WHEN state IN ('queued','running') THEN 'stopping' ELSE state END WHERE run_id=?",(run_id,)) + for member in json.loads(run['members_json']): + self.repo.connection.execute("UPDATE verification_attempts SET state='cancelled',reason='run_stopped_before_dispatch',resource_state='released',updated=? WHERE attempt_id=? AND state='queued'",(now(),member['attempt_id'])) + self.repo._touch(run['task_id']);result={'run_id':run_id,'stop_requested':True} + self.repo._remember('stop',request_id,run_id,result) + with self.lock:self.events.setdefault(run_id,Event()).set() + return result + + def _dispatch(self): + from .runner import run_attempt + try: + while not self.closing: + with self.repo.store.transaction(): + run=self.repo.connection.execute("SELECT * FROM verification_runs WHERE state IN ('queued','running','stopping') ORDER BY created LIMIT 1").fetchone() + if run is None:return + run=dict(run) + if not run['stop_requested']: + self.repo.connection.execute("UPDATE verification_runs SET state='running' WHERE run_id=?",(run['run_id'],)) + with self.lock:event=self.events.setdefault(run['run_id'],Event()) + if run['stop_requested']:event.set() + blocked=False + for member in json.loads(run['members_json']): + result={} + if event.is_set() or self.closing:break + while not event.is_set() and not self.closing: + result=run_attempt(self.service,member['attempt_id'],stop_event=event) + if not result.get('waiting'):break + event.wait(.2) + if result.get('blocked'):blocked=True;break + with self.repo.store.transaction(): + state='blocked' if blocked else 'stopped' if event.is_set() or self.closing else 'completed' + self.repo.connection.execute('UPDATE verification_runs SET state=? WHERE run_id=?',(state,run['run_id'])) + self.repo._touch(run['task_id']) + finally: + with self.lock: + self.thread=None + # Close the enqueue/empty-dispatch race without polling from the UI. + if not self.closing: + with self.repo.store._lock: + pending=self.repo.connection.execute("SELECT 1 FROM verification_runs WHERE state IN ('queued','running','stopping') LIMIT 1").fetchone() + if pending:self.wake() + + def recover(self): + if self.busy:return {'interrupted':0,'blocked':0,'published':0} + result={'interrupted':0,'blocked':0,'published':0} + with self.repo.store.transaction(): + rows=self.repo.connection.execute("SELECT * FROM verification_attempts WHERE state IN ('queued','running','publishing','stopping')").fetchall() + for raw in rows: + row=dict(raw);identity=row['attempt_id'];directory=self.service.data_root/'verification'/'attempts'/identity + if row['state']=='queued':state,resource='interrupted','released' + else: + try: + ready=json.loads((directory/'result-ready.json').read_text(encoding='utf-8')) + value=self.service.artifacts.read(ready['result_ref'],'result') + if value['attempt_id']!=identity or value['generation']!=row['generation']:raise ValueError('身份不符') + from .report import validate_result + validate_result(value,self.service.data_root) + if row['state'] in {'running','publishing'} and self.repo.finish(identity,generation=row['generation'],result=dict(value,result_ref=ready['result_ref'])): + result['published']+=1;continue + except (OSError,ValueError,KeyError,ImportError):pass + try: + proof=json.loads((directory/'resource-released.json').read_text(encoding='utf-8')) + if proof['owner_id']!=row['owner_id'] or proof['resource_state']!='released':raise ValueError('退出未知') + state,resource='interrupted','released' + except (OSError,ValueError,KeyError):state,resource='stopping','unknown' + self.repo.connection.execute('UPDATE verification_attempts SET state=?,resource_state=?,reason=?,updated=? WHERE attempt_id=?', + (state,resource,'上次执行中断;未自动重跑' if resource=='released' else '上次原生进程退出缺少证明,保留现场',now(),identity)) + self.repo._touch(self.repo.item(row['item_id'])['task_id']) + result['blocked' if resource=='unknown' else 'interrupted']+=1 + self.repo.connection.execute("UPDATE verification_runs SET state='interrupted' WHERE state IN ('queued','running','stopping')") + return result + + def begin_shutdown(self): + self.closing=True + with self.repo.store._lock: + runs=[r[0] for r in self.repo.connection.execute("SELECT run_id FROM verification_runs WHERE state IN ('queued','running','stopping')")] + for identity in runs:self.stop(identity,request_id='shutdown:'+identity) + with self.lock: + for event in self.events.values():event.set() diff --git a/src/dx_productivity/trial_task_center/verification/runner.py b/src/dx_productivity/trial_task_center/verification/runner.py index 886a558..9dd8d3d 100644 --- a/src/dx_productivity/trial_task_center/verification/runner.py +++ b/src/dx_productivity/trial_task_center/verification/runner.py @@ -43,6 +43,8 @@ def run_attempt(service,attempt_id,*,stop_event): with service.repo.store.transaction(): service.repo.connection.execute("UPDATE verification_attempts SET state='stopping',resource_state='unknown',reason=? WHERE attempt_id=?",('原生资源退出未知',attempt_id)) return {'published':False,'blocked':True} + from ..batch_resources import write_record + write_record(output/'resource-released.json',{'owner_id':attempt['owner_id'],'resource_state':'released'}) check_cancelled(stop_event) expected=service.artifacts.read(payload['expectation_ref'],'expectations') if payload['expectation_ref'] else None from .rules import evaluate @@ -66,11 +68,17 @@ def run_attempt(service,attempt_id,*,stop_event): 'input_digest':payload['payload_digest'],'raw':raw}) ref=service.artifacts.put('result',result) result['result_ref']=ref + write_record(output/'result-ready.json',{'result_ref':ref}) check_cancelled(stop_event) published=service.repo.finish(attempt_id,generation=attempt['generation'],result=result) return dict(result,published=published) except Exception as error: if attempt: + from ..native_cli import _UNCERTAIN_SCOPES + if _UNCERTAIN_SCOPES: + with service.repo.store.transaction(): + service.repo.connection.execute("UPDATE verification_attempts SET state='stopping',resource_state='unknown',reason=? WHERE attempt_id=?",(str(error),attempt_id)) + return {'published':False,'blocked':True} cancelled=getattr(error,'code','')=='operation_cancelled' result={'attempt_state':'cancelled' if cancelled else 'failed','resource_state':'released', 'verdict':'INCOMPLETE','reason':str(error),'checks':[],'issues':[]} diff --git a/src/dx_productivity/trial_task_center/verification/service.py b/src/dx_productivity/trial_task_center/verification/service.py index eed783f..e56cc5f 100644 --- a/src/dx_productivity/trial_task_center/verification/service.py +++ b/src/dx_productivity/trial_task_center/verification/service.py @@ -19,6 +19,28 @@ class VerificationService: self._intake_lock = RLock() from .queries import VerificationQueries self.queries = VerificationQueries(self.repo) + from .control import VerificationControl + self.control = VerificationControl(self) + self._recovered=False + + def initialize(self): + with self._intake_lock: + if not self._recovered: + self.recover() + self._recovered=True + return self.reconcile_deliveries() + + @property + def busy(self): return self.control.busy + + def start(self, task_id, *, selection=None, request_id): + return self.control.start(task_id,selection=selection,request_id=request_id) + + def stop(self, run_id, *, request_id): return self.control.stop(run_id,request_id=request_id) + def rerun(self, item_id, version, *, request_id): + return self.start(self.repo.item(item_id)['task_id'],selection=((item_id,version),),request_id=request_id) + def recover(self): return self.control.recover() + def begin_shutdown(self): return self.control.begin_shutdown() def list_tasks(self, **kwargs): return self.queries.list_tasks(**kwargs) def read_task(self, task_id, **kwargs): return self.queries.read_task(task_id, **kwargs) diff --git a/tests/ui/test_verification_control.py b/tests/ui/test_verification_control.py new file mode 100644 index 0000000..3089636 --- /dev/null +++ b/tests/ui/test_verification_control.py @@ -0,0 +1,8 @@ +def test_close_and_controls_do_not_block_new_task_creation(ui,qtbot): + page=ui.window.verification_panel + task=ui.service.verification.create_task('任务',request_id='control')['task_id'] + page.open_task(task) + qtbot.waitUntil(lambda:not page.controller.task_query.busy) + assert page.start_button.isEnabled() and page.new_button.isEnabled() + page.begin_shutdown() + assert page.new_button.isEnabled() diff --git a/tests/v1_1/test_verification_control.py b/tests/v1_1/test_verification_control.py new file mode 100644 index 0000000..2f5d1d0 --- /dev/null +++ b/tests/v1_1/test_verification_control.py @@ -0,0 +1,59 @@ +import time +from threading import Event +from test_independent_verification_intake import service +from test_independent_verification_runner import imported +from test_native_cli_netlist import graph + + +def wait_idle(service): + deadline=time.monotonic()+5 + while service.busy and time.monotonic() Date: Tue, 17 Nov 2026 16:03:02 +0800 Subject: [PATCH 12/27] feat: export verification evidence and preserve result history --- docs/user/independent-verification.md | 13 ++ .../trial_task_center/ui/operation_history.py | 1 + .../ui/verification_inspector.py | 3 + .../trial_task_center/verification/queries.py | 18 ++- .../trial_task_center/verification/report.py | 114 ++++++++++++++++++ .../trial_task_center/verification/service.py | 25 ++++ .../trial_task_center/verification/store.py | 9 ++ tests/ui/test_verification_report_actions.py | 5 + tests/v1_1/test_verification_reports.py | 49 ++++++++ 9 files changed, 234 insertions(+), 3 deletions(-) create mode 100644 docs/user/independent-verification.md create mode 100644 src/dx_productivity/trial_task_center/verification/report.py create mode 100644 tests/ui/test_verification_report_actions.py create mode 100644 tests/v1_1/test_verification_reports.py diff --git a/docs/user/independent-verification.md b/docs/user/independent-verification.md new file mode 100644 index 0000000..bba4657 --- /dev/null +++ b/docs/user/independent-verification.md @@ -0,0 +1,13 @@ +# 工程校验 + +在第四个“工程校验”页面随时新建任务。选择修改前、修改后两份已保存的 `.prj` 工程添加比较项,不能选择同一文件或共用数据库的两个工程。已有替换任务不影响新建;替换已保存的成功项会自动交接,缺少前后副本的项显示无法校验,不能用当前工程补造历史版本。 + +“开始全部”处理当前任务中当时待校验/中断的工程;筛选不会缩小这个范围。“校验所选”和“重校验”明确处理所选工程当前版本。运行期间后到的新项或新版本留待下次开始。校验只读副本,不会重新换料或自动换脚。 + +一致表示已覆盖的必查项未发现差异;需关注表示有文字或属性变化需要人工判断;异常表示已证明位号、物理脚号、连接或声明目标等不符合;无法校验表示证据不足。没有固定换料清单时始终显示“未核对换料规则”。执行结束不等于工程一致。 + +选择工程,在右侧选择位号查看固定脚号的前后接线图和逐脚事实。红线对应连接变化;纯名称变化以关注提示。图由网表生成,不是原理图截图。原始证据入口会核对摘要;历史版本仅供查看,不改变当前结论。导出报告包含同一份图表、检查范围、输入和尝试摘要,不复制整个工程。 + +停止采用安全收尾。未派发项保留待校验,已开始项保留停止记录。重启不会自动重跑;缺少进程退出证明的项保留现场并暂停新的原生导出,不按 PID 猜测或终止其他进程。 + +首版未证明引脚级 Value 读取和确切库内部引脚→焊盘映射,页面明确未覆盖。电气类型按原生码展示,不臆造语义。本网表比较不宣称完成 ERC、PCB 或封装库内部正确性验证。普通操作历史清空和运行日志保留不会删除校验快照与证据。 diff --git a/src/dx_productivity/trial_task_center/ui/operation_history.py b/src/dx_productivity/trial_task_center/ui/operation_history.py index 21a2e99..4034cc5 100644 --- a/src/dx_productivity/trial_task_center/ui/operation_history.py +++ b/src/dx_productivity/trial_task_center/ui/operation_history.py @@ -18,6 +18,7 @@ STATES={'verified':'已核验完成','no_match':'未命中','failed':'失败','f 'uncertain':'待核验','saved_unverified':'保存待核验','skipped':'已跳过','recorded':'已记录', 'running':'执行中','paused':'已暂停','pending':'待执行','restored':'已恢复'} OPERATIONS={'quick_run_executed':'替换执行','quick_run_prepared':'准备执行', + 'verification_completed':'工程校验', 'quick_run_recovered':'核验恢复','quick_run_queue_paused':'暂停执行', 'quick_run_retry_prepared':'准备失败项重试','create_project_tasks':'创建工程任务', 'create_task':'新建任务','update_task':'编辑任务','delete_task':'归档任务', diff --git a/src/dx_productivity/trial_task_center/ui/verification_inspector.py b/src/dx_productivity/trial_task_center/ui/verification_inspector.py index 0583856..59053b3 100644 --- a/src/dx_productivity/trial_task_center/ui/verification_inspector.py +++ b/src/dx_productivity/trial_task_center/ui/verification_inspector.py @@ -72,6 +72,9 @@ class VerificationInspector(QWidget): self.versions.addItem(f'输入 v{version}',version) self.versions.setCurrentIndex(self.versions.findData(record['input_version']));self.versions.blockSignals(False) result=((record.get('attempt') or {}).get('result') or {}) + if record.get('evidence_error'): + self.set_evidence(None);self.heading.setText(record['display_name']+' · 证据不可用') + self.facts.setPlainText(record['evidence_error']);return self.set_evidence(result.get('evidence')) self.heading.setText(record['display_name']+' · '+{'CONSISTENT':'一致','WARNING':'需关注','DIFFERENT':'异常','INCOMPLETE':'无法完整校验'}.get(result.get('verdict'),'待校验')) self.facts.setPlainText(json.dumps({'范围':result.get('scope',record['scope']),'检查':result.get('checks',[]), diff --git a/src/dx_productivity/trial_task_center/verification/queries.py b/src/dx_productivity/trial_task_center/verification/queries.py index b6929c3..442ad68 100644 --- a/src/dx_productivity/trial_task_center/verification/queries.py +++ b/src/dx_productivity/trial_task_center/verification/queries.py @@ -43,7 +43,14 @@ def paginate(rows,cursor,limit,binding,maximum): class VerificationQueries: - def __init__(self,repo):self.repo=repo + def __init__(self,repo):self.repo=repo;self.validator=None + + def _validate(self,row,attempt): + if self.validator and attempt and attempt['state']=='succeeded': + try:self.validator(attempt) + except (ValueError,OSError,KeyError,TypeError) as error: + row.update(status='unavailable',verdict='INCOMPLETE',evidence_error=str(error)) + return row def _rows(self,task_id,control=None): checkpoint(control) @@ -58,7 +65,12 @@ class VerificationQueries: LEFT JOIN verification_attempts a ON a.attempt_id=(SELECT attempt_id FROM verification_attempts WHERE item_id=i.item_id AND input_version=i.current_version ORDER BY generation DESC LIMIT 1) WHERE i.task_id=? ORDER BY i.rowid''',(task_id,)).fetchall() - return [project(row) for row in rows] + result=[] + for row in rows: + checkpoint(control);row=project(row) + if self.validator and row['attempt_state']=='succeeded':self._validate(row,self.repo.attempt(row['attempt_id'])) + result.append(row) + return result def list_tasks(self,*,query='',cursor=None,limit=50,read_control=None): with self.repo.store.transaction(): @@ -97,7 +109,7 @@ class VerificationQueries: attempt_state=attempt['state'] if attempt else None,reason=attempt['reason'] if attempt else '', verdict=(attempt['result'] or {}).get('verdict') if attempt else None) history=[dict(r) for r in self.repo.connection.execute('SELECT input_version,generation,attempt_id,state FROM verification_attempts WHERE item_id=? ORDER BY input_version DESC,generation DESC',(item_id,))] - return dict(project(row),payload=revision['payload'],attempt=attempt,history=history) + return dict(self._validate(project(row),attempt),payload=revision['payload'],attempt=attempt,history=history) def read_issues(self,attempt_id,*,kind='',cursor=None,limit=100,read_control=None): checkpoint(read_control) diff --git a/src/dx_productivity/trial_task_center/verification/report.py b/src/dx_productivity/trial_task_center/verification/report.py new file mode 100644 index 0000000..7b974fb --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/report.py @@ -0,0 +1,114 @@ +"""HTML and JSON views of the exact immutable evidence shown in the workspace.""" +from html import escape +import json +import os +from pathlib import Path +from uuid import uuid4 +from ..native_netlist import _hash +from ..batch_resources import write_record +from .contracts import fail,digest +from .evidence import verify_evidence + + +def validate_result(result,root=None): + evidence=result.get('evidence') + if evidence: + verify_evidence(evidence) + for raw in evidence['binding'].get('raw',()): + path=Path(raw['path']).resolve() + if root is not None and not path.is_relative_to(Path(root).resolve()):fail('证据文件不属于本任务库。') + try: + if _hash(path)!=raw['sha256']:fail('原始证据已损坏。','verification_evidence') + except OSError:fail('原始证据已丢失。','verification_evidence') + + +def text(value): + if isinstance(value,(dict,list,tuple)):value=json.dumps(value,ensure_ascii=False,sort_keys=True) + return escape(str(value if value is not None else '未知')) + + +STYLE='body{font:14px "Segoe UI","Microsoft YaHei",sans-serif;color:#34445b;background:#f5f7fa;margin:24px}main{background:white;padding:24px;border-radius:12px}table{border-collapse:collapse;width:100%;margin:16px 0}td,th{border:1px solid #dae2eb;padding:9px;text-align:left;vertical-align:top}pre{white-space:pre-wrap;overflow-wrap:anywhere}.error{color:#b83d4a}.warning{color:#9c6b1e}svg{max-width:100%;height:auto}' + + +def diagram(pins): + height=max(100,70+len(pins)*90);out=[f''] + for col,phase,title in ((0,'before','修改前'),(1,'after','修改后')): + x=col*450+16;out.append(f'{title}') + for n,pin in enumerate(pins): + y=60+n*90;row=pin[phase];color='#b83d4a' if pin['connection_changed'] else '#9c6b1e' if pin['text_changed'] else '#39817d' + out.append(f'脚 {text(pin["endpoint"][2])} · {text(row["logical_name"] if row else None)}') + out.append(f'') + nets=row['nets'] if row else [] + label=';'.join(net['name']+' · '+', '.join(e[1]+'.'+e[2] for e in net['endpoints']) for net in nets) or ('明确未连接' if row else '未知') + out.append(f'{text(label)}') + return ''.join(out)+'' + + +def item_html(result): + validate_result(result) + evidence=result.get('evidence') or {};pins=evidence.get('pins',[]) + out=[f'

{text(result.get("display_name","工程校验"))}

',f'

{text(result.get("verdict","未完成"))}

', + f'

{text(result.get("scope","未核对换料规则"))} · 由网表生成 · 未覆盖:封装库内部映射、引脚级 Value

'] + keys=sorted({tuple(p['endpoint'][:2]) for p in pins}) + for key in keys: + subset=[p for p in pins if tuple(p['endpoint'][:2])==key] + out.append(f'

{text(key[1])} · {text(key[0])}

');out.append(diagram(subset)) + out.append('') + for pin in subset: + out.append(f'') + out.append('
物理脚修改前修改后事实
{text(pin["endpoint"][2])}
{text(pin["before"])}
{text(pin["after"])}
{"连接变化" if pin["connection_changed"] else "文字变化" if pin["text_changed"] else "未发现变化"}
') + out.append('

判断依据与范围

'+text({key:result.get(key) for key in ('checks','issues','uncovered','attempt_id','input_version','input_digest','policy')})+'
') + out.append('

原始证据定位与摘要

'+text(evidence.get('binding',{}))+'
') + return ''.join(out) + + +def render_item_report(result_ref,destination): + destination=Path(destination) + if destination.exists():fail('报告文件已存在,请换一个名称。') + html='工程校验报告
'+item_html(result_ref)+'
' + destination.parent.mkdir(parents=True,exist_ok=True) + temporary=destination.with_name(destination.name+'.'+uuid4().hex+'.tmp') + try: + temporary.write_text(html,encoding='utf-8') + # On Windows rename does not overwrite an existing destination. + if destination.exists():fail('报告文件已存在。') + temporary.rename(destination) + finally:temporary.unlink(missing_ok=True) + return destination + + +def export_task(service,task_id,destination,*,request_id): + body=[task_id,str(Path(destination).resolve())] + with service._intake_lock: + with service.repo.store._lock: + old=service.repo._request('export',request_id,body) + if old is not None: + path=Path(old['path']) + if not path.is_file() and not path.is_dir():fail('先前导出的报告已丢失,请重新导出。') + return path + with service.repo.store.transaction(): + task=service.repo.task(task_id);rows=service.queries._rows(task_id) + records=[service.read_item(row['item_id']) for row in rows] + for row in records: + if row.get('evidence_error'):fail('证据不可用,不能导出为有效报告:'+row['evidence_error']) + snapshot=dict(task,items=records) + root=Path(destination).resolve();root.mkdir(parents=True,exist_ok=True) + output=root/f'verification-{task_id[:12]}-v{task["view_revision"]}-{digest(request_id)[:8]}' + if output.exists():fail('报告目录已存在。') + staging=root/('.verification-'+uuid4().hex);staging.mkdir() + write_record(staging/'task.json',snapshot) + content=[f'

{text(task["name"])}

视图版本 {task["view_revision"]} · 生成时冻结,待校验/运行中项尚未完成。

    '] + for row in records: + filename=row['item_id']+f'-v{row["input_version"]}.html' + result=((row.get('attempt') or {}).get('result') or {}) + if result: + render_item_report(dict(result,display_name=row['display_name']),staging/filename) + content.append(f'
  • {text(row["display_name"])} · {text(row["status"])}
  • ') + else:content.append(f'
  • {text(row["display_name"])} · {text(row["status"])} · 未完成/无法校验
  • ') + content.append('
') + (staging/'index.html').write_text('
'+''.join(content)+'
',encoding='utf-8') + # Roundtrip before publication; the destination never contains a partial report. + json.loads((staging/'task.json').read_text(encoding='utf-8')) + staging.rename(output) + with service.repo.store.transaction():service.repo._remember('export',request_id,body,{'path':str(output)}) + return output diff --git a/src/dx_productivity/trial_task_center/verification/service.py b/src/dx_productivity/trial_task_center/verification/service.py index e56cc5f..76d4003 100644 --- a/src/dx_productivity/trial_task_center/verification/service.py +++ b/src/dx_productivity/trial_task_center/verification/service.py @@ -19,6 +19,7 @@ class VerificationService: self._intake_lock = RLock() from .queries import VerificationQueries self.queries = VerificationQueries(self.repo) + self.queries.validator = self.validate_attempt from .control import VerificationControl self.control = VerificationControl(self) self._recovered=False @@ -47,6 +48,30 @@ class VerificationService: def read_item(self, item_id, **kwargs): return self.queries.read_item(item_id, **kwargs) def read_issues(self, attempt_id, **kwargs): return self.queries.read_issues(attempt_id, **kwargs) + def export_task(self, task_id, destination, *, request_id): + from .report import export_task + return export_task(self,task_id,destination,request_id=request_id) + + def validate_attempt(self, attempt): + result=attempt.get('result') or {} + if not result.get('result_ref'): return + stored=self.artifacts.read(result['result_ref'],'result') + if stored!={k:v for k,v in result.items() if k!='result_ref'}:fail('结果记录与不可变证据不符。') + from .report import validate_result + validate_result(stored,self.data_root) + payload=self.repo.revision(attempt['item_id'],attempt['input_version'])['payload'] + for key in ('before_ref','after_ref'):self.artifacts.read(payload[key],'snapshot') + + def open_evidence(self, attempt_id, artifact_id): + attempt=self.repo.attempt(attempt_id);self.validate_attempt(attempt) + raw=next((r for r in (attempt['result'] or {}).get('evidence',{}).get('binding',{}).get('raw',[]) if r['artifact_id']==artifact_id),None) + if raw is None:fail('原始证据标识不存在。') + path=Path(raw['path']).resolve() + if not path.is_relative_to(self.data_root/'verification'):fail('原始证据越界。') + import os + os.startfile(path) + return path + def create_task(self, name, *, request_id): return self.repo.create_task(name,request_id=request_id) diff --git a/src/dx_productivity/trial_task_center/verification/store.py b/src/dx_productivity/trial_task_center/verification/store.py index 6572b11..d1b1634 100644 --- a/src/dx_productivity/trial_task_center/verification/store.py +++ b/src/dx_productivity/trial_task_center/verification/store.py @@ -182,4 +182,13 @@ class VerificationRepository: self.connection.execute('UPDATE verification_attempts SET state=?,result_json=?,resource_state=?,updated=? WHERE attempt_id=?', (state,encode(result),'released',now(),attempt_id)) self._touch(self.item(attempt['item_id'])['task_id']) + from ..history_store import HistoryRepository + item=self.item(attempt['item_id']);task=self.task(item['task_id']) + HistoryRepository(self.store).append(task_id=task['task_id'],task_name=task['name'], + project_path=item['project_key'],operation='verification_completed', + state='verified' if result.get('verdict')=='CONSISTENT' else 'failed' if result.get('verdict')=='DIFFERENT' else 'uncertain', + summary='工程校验:'+str(result.get('verdict','INCOMPLETE')), + details={'attempt_id':attempt_id,'input_version':attempt['input_version'],'generation':generation, + 'verdict':result.get('verdict'),'scope':result.get('scope')}, + source_key='verification:'+attempt_id) return True diff --git a/tests/ui/test_verification_report_actions.py b/tests/ui/test_verification_report_actions.py new file mode 100644 index 0000000..442a900 --- /dev/null +++ b/tests/ui/test_verification_report_actions.py @@ -0,0 +1,5 @@ +def test_report_action_available_for_empty_task_without_cad(ui,qtbot): + task=ui.service.verification.create_task('报告',request_id='report')['task_id'] + page=ui.window.verification_panel;page.open_task(task) + qtbot.waitUntil(lambda:not page.controller.task_query.busy) + assert page.export_button.isEnabled() and page.new_button.isEnabled() diff --git a/tests/v1_1/test_verification_reports.py b/tests/v1_1/test_verification_reports.py new file mode 100644 index 0000000..33b00a0 --- /dev/null +++ b/tests/v1_1/test_verification_reports.py @@ -0,0 +1,49 @@ +import copy +import json +from threading import Event +import pytest +from test_independent_verification_intake import service +from test_independent_verification_runner import imported +from test_independent_verification_rules import export,evaluate +from dx_productivity.trial_task_center.errors import TaskCenterError + + +def test_html_escapes_and_uses_same_fixed_pin_facts(tmp_path): + from dx_productivity.trial_task_center.verification.report import render_item_report + from dx_productivity.trial_task_center.verification.evidence import build_evidence + a=export();b=copy.deepcopy(a);b['graph']['components']['a']['pins']['loop']['number']='2';b['graph']['components']['a']['pins']['GND']['number']='1' + result=evaluate(a,b);result['evidence']=build_evidence(a['graph'],b['graph'],result['issues'],binding={}) + result['display_name']='' + path=render_item_report(result,tmp_path/'report.html') + html=path.read_text(encoding='utf-8') + assert '