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..e4bd6b5 --- /dev/null +++ b/docs/research/2026-11-17-pin-metadata-capability.md @@ -0,0 +1,9 @@ +# 引脚字段读取范围 + +FREEFORM / FLAT BLOCKS 原生文本中的 `Pin 名称\tnum 编号\ttype 类型码` 可以与已解析图的实例、位号、物理脚号核对。适配器保留文件 SHA256 和行号,重复或无法绑定的字段不进入已证明清单。类型码按原文展示,不臆造类型语义。 + +自建格式夹具验证了逻辑名和电气类型码。另对已有工程的两份已保存副本执行了真实原生只读导出:前后各 57 个器件,83 个物理引脚取得了名称和类型码的原文证明。验收记录在本机 `D:/dx-vfy-native-final/acceptance.json`;原始客户工程和网表不提交 Git。 + +引脚级 Value 尚未在该格式中证明,保持 unknown;器件 Value 不能代替它。确切库版本内部的引脚到焊盘映射尚未支持,保持未覆盖。若检查计划要求这些未证明字段,结论必须为 INCOMPLETE(已有明确硬异常时仍为 DIFFERENT)。 + +探针:`python tools/probe_verification_pin_metadata.py <受管导出/netlist.json>`,只读已有输出,不调用 CAD、不修改工程。 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..ded2e43 --- /dev/null +++ b/docs/superpowers/plans/2026-11-17-independent-verification-new-features.md @@ -0,0 +1,324 @@ +# 独立校验新增功能 Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use `superpowers:executing-plans` to implement task-by-task. N01–N12 implementation and local development-package acceptance are complete. Continuous full-suite stability remains a release gate; see the acceptance record. 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)读取。本文件是该入口下的逐任务清单,N01~N12 已实施并完成本地开发包验收;既有连续全量回归的时序波动保留为发布门槛,详见验收记录。 + +## 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/control.py`、`V/ownership.py` | 冻结运行范围、持久停止、跨窗口进程归属和恢复证明 | N10 | +| `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仍输出变化事实。 + +- [x] 写空结果、缺必查、错误与未知并存、警告、可选未知、无预期清单的失败测试: + +```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' +``` + +- [x] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_independent_verification_contracts.py -q`,确认新合同尚不存在而失败。 +- [x] 实现严格字段、枚举、摘要、整数版本与受管引用结构校验;拒绝外部任意输出路径,UI不传来源字段。输入字段按规范4.1,check_plan明确 required/optional/excluded。 +- [x] 实现纯汇总优先级,核心逻辑固定为: + +```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。覆盖清单独立计算。 + +- [x] 重跑本组,补 actual属性值不能反推expected、not_requested不计已检查、没有规则时scope文字不能“换料符合”的断言。 +- [x] 对照规范J01~J13与状态表自审字段;保留原始文字及证据引用,不在合同层猜测引脚功能。 +- [x] 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由服务完成。 + +- [x] 写旧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() +``` + +- [x] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_independent_verification_store.py -q`,确认失败。 +- [x] 建 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'); +``` + +- [x] 实现事务内版本指针移动、逐条接收和CAS generation;批量外层错误全拒绝,逐项错误返回原因,已接收其他项不回滚。保存request摘要,拒绝同request_id异文。 +- [x] 用真实临时SQLite跑本组及既有schema/store回归;核对旧execution_operations与重试额度字节/行值未被新操作改写。 +- [x] 故障注入提交前/提交后;返回值在事务内准备,不能因COMMIT后的额外尾读失败误报未接收;记录同一 before 新after与新before分项的区别。 +- [x] 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,无来路枚举。默认自动接收容器名为“校验任务”,以持久交接关联键去重,用户可改名。 + +- [x] 写两份工程同文件/数据库别名、捕获时变化、成功交接缺before、未成功结果拒绝、重复交接、一次批量和分次输入等价的测试。自建文件只用于事务/捕获测试,不假称可打开CAD工程。 +- [x] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_independent_verification_intake.py -q`,确认失败。 +- [x] 复用capture_project,受管目录外输入先检查稳定性;两个文件最终数据库同源也要拒绝。已冻结交接只核验引用,不打开原CAD或重新捕获旧before。 +- [x] 对已落盘成功范围建规范inputs;expectation_ref来自冻结清单/有效回执,不用after反推。补有界交接对账:首次接收和重启/进入校验页重扫未确认通知都用同submission键,落库回执作为完成依据。 +- [x] 重跑本组;让导入/发布期间的替换和恢复入口抛AssertionError,证明只创建校验记录。成功工程缺证据仍可见,错误输入不能将旧baseline换成当前工程。 +- [x] 对照接口确认当前能批量传、未来能乱序增量传;输入接收不创建queued尝试,不强制切走用户正在看的任务。 +- [x] 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)`只统计当前版本。 + +- [x] 写24项计数、旧版不重复计数、重校验转排队后旧绿灯退出当前、同名不同身份、筛选与整任务操作范围分离的测试。 +- [x] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_independent_verification_queries.py -q`,确认失败。 +- [x] 实现“输入→当前尝试→结论→可执行动作”的单一投影;执行succeeded且verdictDIFFERENT必须显示异常,而非通过。空任务可新建/加工程,活动任务不禁用创建其他任务。 +- [x] 参数化查询实现50任务/100工程/100问题上限,搜索名称、路径及已有issue位号/料号;转义LIKE的百分号/下划线。分页cursor绑定过滤、排序和view_revision,身份不从行号推断。 +- [x] 跑本组与既有任务只读查询测试,核对“24=16一致+2警告+1异常+1无法校验+4待校验,已处理20”;暂停/中断单列不当一致。 +- [x] 用并发读/新版本发布验证快照计数一致;旧attempt结果只进入历史,不刷新当前绿色。 +- [x] 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前本适配可返回已有比较事实并显式缺少扩展检查,不能编造完整结论。 + +- [x] 写任意独立任务可运行、原输入不变、缺工具不启动CAD、旧缓存损坏重导出、并发领取唯一、资源忙排队的测试。runner用受控OwnedCliScope/现有graph夹具,实际持久库和文件发布链不替换为固定成功值。 +- [x] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_independent_verification_runner.py -q`,确认失败。 +- [x] 依照E03~E07核验固定引用;捕获/导出只走既有native_netlist。首版独立runner一次领取一个工程对,前后导出顺序运行,避免复制旧批次pool再叠加并发。若原生资源准入不可证明可并行,则留队列等待;不以该等待禁用新建。 +- [x] 组织比较调用与暂存产物;先按E10确认自有CLI退出,再按E11发布结果及CAS finish。原异步导出/旧finish行为不被替换为新全局队列,接收既有完整证据时可以只复核/复用而不额外开进程。 +- [x] 跑新组及两个旧网表组;断言替换派发数、CAD启动数、execution_operations写次数均为0,旧入口的暂停与缓存合同不退化。 +- [x] 注入导出失败和发布中断;确认旧结果不覆盖、迟到attempt不更新当前。记录新执行器与旧资源修复的责任边界,不用本任务修退出helper。 +- [x] 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与有意声明空变化清单须区分。 + +- [x] 用真实最小graph夹具写J01~J13反例:断线、短接、交换物理脚、位号增删、用户网名、无清单属性、正常目标变化、非目标变化、命名警告、必查unknown。固定脚号互换测试独立于名称相似度。 +- [x] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_independent_verification_rules.py -q`,确认失败。 +- [x] 复用已有完整图/物理端点语义,建立只读对应视图;延用最新实例范围+生效位号唯一绑定,UID仅保留原始证据,其缺失/重复/变化不得否定已证明的位号对应。真实位号/实例歧义仍unknown。连接按完整端点集合比较,单端网络与未连接不混用。 +- [x] 按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语义不由模型判断。 + +- [x] 跑本组及现有physical pin/逻辑改名测试;证明默认旧比较器结果不被全局放宽,网名变化不会套入引脚名称规则。 +- [x] 检查错误优先、未知必查、警告、范围一致四类;有已知反脚加缺失属性时仍DIFFERENT,同时保留unknown列表。 +- [x] 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及原因,不用空字典代表映射相同。 + +- [x] 写引脚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 +``` + +- [x] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_verification_pin_metadata.py -q`,确认失败。 +- [x] 探针只在用户工程已保存副本/受管导出上读取现有原生输出,记录确切字段、版本、存在性和物理脚绑定。先确认能否读出,不能凭类型名发明COM方法或回退CAD采集;探针不直接进入生产导入链。 +- [x] 只有已证明的字段进入最小解析适配;无引脚Value就保留unknown,不用逻辑名或器件Value代替。库内映射默认未覆盖,只有取得真实版本/符号/Cell/脚号证据才实现对应分支。 +- [x] 运行本组及N06,使用自建可提交fixture覆盖loop/outloop、同号不同文字、同名不同脚和已证实映射交换;客户报告只本地保存,仓库仅自建摘录。 +- [x] 写能力报告:已验证字段/格式、未覆盖项、真实读取或纯夹具证据;无法验证的能力不阻止A基础页交付,但必查请求该能力时必须INCOMPLETE。 +- [x] 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` 只生成确定性绘图数据,不调用图片/语言模型。 + +- [x] 写R12 1/2互换、短接多对端、纯改名不画红断线、未知映射、图页未知与证据摘要损坏测试。前后pin1的绘制顺序必须相同,不能自动互换位置使图看起来一致。 +- [x] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_verification_evidence.py -q`,确认失败。 +- [x] 从N06事实产生唯一issue_id;图和表共享同一数据结构,不分别拼判断。端点按固定脚号排列,变化线给出added/removed及原网络名,保留多gate与实例身份。 +- [x] 将issue绑定不可变raw文件、摘要与可定位段落/对象键;图页无法确定则明确未定位。图标注“由网表生成”,不画伪原理图截图,不用生成模型解释电气正确性。 +- [x] 跑本组与N06;反例断言每条红色连线都有对应连接error/差异,纯文字warning没有虚构接线变化。 +- [x] 检查独立输入无expectation时证据仍可读;原生身份列差异与有效料号显示分开,不改写raw以统一数值。 +- [x] 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查询,未来增量输入仅更新结果查询,不重新设计来路入口。 + +- [x] 写四导航映射、始终可新建、已有任务时独立导入、无来源横条、选择保持、不同任务延迟回调、DIFFERENT不显示通过的Qt测试。沿用既有`ui` fixture,但不更改其修复逻辑。 +- [x] Run `.venv/Scripts/python.exe -m pytest tests/ui/test_verification_workspace.py tests/ui/test_verification_inspector.py -q`,确认失败。 +- [x] 按最终图建立任务列表/状态筛选/工程表/右证据/固定底栏;main_window按页面对象明确映射四导航,DSH懒加载不被触发。新建对话框只含名称与可选前后工程,不要求来源选择。 +- [x] QPainter或Qt原生控件渲染N08确定性图,表格同源;保持8–12px圆角、白色数据面、已有亚克力外框和减少透明度设置。980宽改可展开详情,不遮住开始/停止按钮。 +- [x] 跑本组、现有history/DSH导航与样式测试;无后台run时点击导航或选工程只查询,不隐式导出。 +- [x] 人工看1280×880、980×700及125/150%缩放;右侧R12对照保持1/2位置,警告/未知文字可读。静态图片仅视觉参考,不算功能验收。 +- [x] 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()`。停止/恢复均不调用替换停止/准备重试/核验恢复函数。 + +- [x] 写重复点击、冻结范围不吞新项、当前v2不被v1完成覆盖、取消与提交竞争、进程退出未知、重启不自动执行的测试。queued取消保留历史;整run停止前从未派发项投影回待校验,用户单项取消显示已停止。 +- [x] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_verification_control.py tests/ui/test_verification_control.py -q`,确认失败。 +- [x] 实现命令幂等与持久stop_requested;领取前/后、原生导出阶段和发布CAS前检查。终态提交先发生时保留真实结果;取消先发生时旧callback不能提交当前结果。 +- [x] 实现重启核实OwnedCli身份/退出、F15产物补提交和interrupted;归属核对使用原owner/token/进程创建身份,不仅凭PID,以免PID复用误杀外部进程。未知资源留stopping,禁止盲目新导出。新attempt递增generation,旧terminal不改回running。 +- [x] 跑本组及旧网表暂停组;在全部校验控制测试中将既有替换动作设为抛AssertionError,证明不会触发。GUI关闭不join/wait原生进程,通知安全结束后再关闭。 +- [x] 受控慢导出期间切页、建新任务和停止,验证事件循环可响应;新工程后到保持待校验,不无限扩展当前run范围。 +- [x] 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,可在运行中生成并明确未完成项。 + +- [x] 写同版本报告/图表一致、HTML转义、原证据损坏、导出重名、运行中快照、清历史不删证据、缓存不可伪装新结果的测试。 +- [x] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_verification_reports.py tests/ui/test_verification_report_actions.py -q`,确认失败。 +- [x] 从N08证据包渲染HTML/JSON,字段转义,原始文件只引用或用户明确选择后打包;默认不复制整个工程。报告固定输入/策略/工具/attempt摘要与检查范围。 +- [x] 暂存→完整性核验→原子发布,重名目录明确错误不混写;HistoryRepository用稳定source_key防重复记录校验事件,此source_key为事件去重而非UI来源类型。 +- [x] 跑本组与retention/history回归,核对当前/活动引用不可被普通日志清空删除,失去证据时显示不可用而非缓存绿灯。 +- [x] 写用户说明:新建/自动接收无需来源、开始范围、警告/异常/未知、版本更新、停止重启、对照图与证据查看;不宣称ERC/PCB已检查。 +- [x] 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 ...` 明确分开;后者只读两份合法已保存工程,不执行换料。原有真实新换料闭环由已有执行器/验收工具交接,本任务只验证新校验任务能接收和复核,不重做其他任务的修复。 + +- [x] 用真实临时SQLite、受控CLI和完整文件发布链建立端到端用例:两份工程创建、批量成功交接、增量乱序、24工程计数、命名警告、反脚、缺基线、停止、重启、v1/v2竞争、报告。每用例记录实际派发与原工程摘要,不用单纯固定绿灯填页面。 +- [x] Run `.venv/Scripts/python.exe -m pytest tests/v1_1/test_independent_verification_acceptance.py tests/ui/test_verification_acceptance.py -q`,确认缺口;前置已全部实现时允许首跑通过,不为制造red破坏实现。 +- [x] 实现验收CLI串联公开接口并非零退出失败,记录模型图片仅参考、新功能真实证据另存。真实只读副本上复核引脚字段与层级范围;未知范围保持未知,不修改源工程制造反例。 +- [x] 运行全部新增组、现有网表/BOM/导航/关闭/DSH及打包回归;再按仓库默认配置运行默认suite一次。记录当前分支并行修复是否已合入,不能冒用旧108项或旧EXE结果。 +- [x] 在实际包中验证四导航、缺CAD工具仍可新建/导入记录/看已有报告、正确unavailable、正常关闭;不携带厂商exe和客户fixture。若可用真实本次成功回执,验证自动交接与手工独立输入共存且零重复换料。 +- [x] 输出验收矩阵每项结果、通过数量、精确构建/输入/策略摘要、失败现场和未测范围;未取得真实引脚Value/映射证明时保留未覆盖声明。 +- [x] 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..06aca1f --- /dev/null +++ b/docs/superpowers/plans/2026-11-17-verification-development.md @@ -0,0 +1,158 @@ +# 工程校验功能开发与交付计划 + +> **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. N01–N12 implementation and local development-package acceptance are complete; continuous full-suite stability remains a release gate. + +**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. 交接状态 + +### N12 后续闭环标准(2026-11-18) + +所有后续任务按[闭环标准 v1](../../testing/verification-closed-loop-standard.md)留证;不再用“导入成功”“文件已生成”或历史分组通过数量单独宣布闭环完成。批量添加见[验收记录](../../testing/2026-11-18-verification-batch-import.md)。 + +- [x] C01~C05:开始前冻结名单/输入/策略,核对实际运行成员、预期结论、同源图表与报告、原文和退出证明;源文件不变、新增换料操作为0。 +- [x] C06:实际包正常关闭后重启,证据可回读,尝试数不增加。 +- [x] C07:实际包单项重校验,新attempt及generation递增,旧结果/报告不被覆盖。 +- [x] C08受控回归:反脚、命名警告、必查未知、停止/资源未知、版本竞争和单项失败后继续的服务/Qt反例。 +- [x] C08实际包补充:原生导出失败项先运行,后续正常项仍完成;混合批次的报告、重启和重校验均通过,见[本轮闭环验收](../../testing/2026-11-18-verification-closed-loop.md)。 +- [x] C08实际包停止与资源未知:已有各自独立现场,见[剩余闭环执行记录](2026-11-18-verification-remaining-closure.md);三工程停止/继续和自有实例异常退出后资源未知保护分别通过。 +- [x] 真实已保存换料回执触发的自动交接实际包闭环:新临时副本真实换料1项,自动交接后校验、报告、重启和重校验通过,校验期间换料增量0;见同一执行记录。 +- [x] 连续默认全量:两轮2276 passed,固定提交上的最终运行0失败/0错误,631个产品/测试/工具文件运行前后不变;扩展120 passed、1 skipped(缺7-Zip)。未改旧时序断言,完整结果见[最终闭环验收](../../testing/2026-11-18-verification-final-closure.md)。 + +单次只读验收入口为 `tools/verify_independent_verification.py --expect-verdict ...`,明确只覆盖 C01~C05;实际包入口为 `tools/accept_verification_closed_loop.py`,覆盖独立输入 C01~C07,并可用 `--fault-batch` 增加原生失败隔离反例。未测项在JSON里保留not_run。测试失败或标准不符均非零退出;已有换料历史采用执行前基线,不能要求历史总数为0。 + +用户授权的 N01~N12 已顺序实现、分步提交并完成本地开发包验收。11月18日后续批量导入及四项剩余闭环均已完成:独立输入和真实换料保存交接两条实际包路径通过,停止与资源未知保护通过,固定版本的默认全量2276项通过。历史波动记录保留,不宣称修复其全部根因。未合并、推送或发布,本分支没有复制另一修复任务的未提交修改。 + +实施进度及验证结果见 docs/testing/2026-11-17-independent-verification-acceptance.md。后续开发以本入口和[N01~N12清单](2026-11-17-independent-verification-new-features.md)共同为准,11月6日的V/U旧计划保留为历史参考,不能再并行照旧重建后端或来源界面。 diff --git a/docs/superpowers/plans/2026-11-18-verification-remaining-closure.md b/docs/superpowers/plans/2026-11-18-verification-remaining-closure.md new file mode 100644 index 0000000..e6eeae7 --- /dev/null +++ b/docs/superpowers/plans/2026-11-18-verification-remaining-closure.md @@ -0,0 +1,16 @@ +# 剩余四项闭环执行计划 + +用户确认顺序实施并允许在工具新建的临时副本中执行真实换料。使用 `codex/independent-verification` 工作区,不修改另一修复工作区,不合并/推送/发布。 + +- [x] 实际包停止、重启不重跑、继续未派发项、明确重校验已停止项。三工程现场:`D:/dx-vfy-stop-three-20261118/acceptance.json`,两项未派发均保持待校验,继续和重校验的报告绑定通过。 +- [x] 本工具自有实例异常退出,按PID和创建时间证明后才中断;重启保留资源未知,不派发后续原生导出,仍能新建校验。现场:`D:/dx-vfy-owner-exit-20261118/acceptance.json`。不为闭环伪造退出证明,不终止其他进程。 +- [x] 真实换料交接:临时副本 RV05 从4100-CA0000-T7替换至4100-CA0000-T0,RV11保持;真实保存回执自动登记,校验/报告/重启/重校验不新增换料。新现场 `D:/dx-vfy-real-handoff-20261118-v2/acceptance.json` 和其 `verification-loop/acceptance.json` 均通过;替换操作1条且verified,校验阶段增量0,声明属性检查为expected_change,原始样例及库LMC摘要未变。 +- [x] 最终回归:两轮完整默认suite均为2276 passed;最终固定提交XML `D:/dx-vfy-fixed-default-20261118.xml`,运行前后631个产品/测试/工具文件摘要不变。执行恢复与打包扩展120 passed、1 skipped(缺官方7-Zip),最终包运行时和资源释放复核通过。没有用分组复核替代连续通过,也未放宽旧断言。 + +验收工具新增 `--control-scenario stop|owner-exit`、`--handoff-data`,真实换料入口为 `tools/accept_verification_saved_handoff.py`。后者只接受全新外部输出目录,先原生导出证明固定RV05/RV11前提,使用已有BOM/执行器和实际EXE运行;不通过直接修改SQLite制造回执。 + +交接场景的before来自不可变历史捕获,不能要求它的源文件在真实替换后仍保留旧字节;`freeze_inputs(..., historical_before=True)`要求冻结预期清单,核验历史副本完整性,以已保存after的源摘要建立校验只读基线。默认独立导入仍要求两个源与导入时摘要相同。 + +每项完成需:输入名单/摘要和预期在执行前固定;运行及报告身份一致;原始样例/共享库不变;测试副本仅发生一次授权替换;校验阶段新增换料为0;停止/异常状态不能被显示为一致。按[闭环标准](../../testing/verification-closed-loop-standard.md)逐项留passed/failed/not_run。 + +最终四项记录见[剩余闭环验收](../../testing/2026-11-18-verification-final-closure.md)。保留分支与独立工作目录;未合并、推送或发布。Value/库内部映射仍属于明确未覆盖的能力边界。 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 写入、改动其他任务的修复或发布程序。 diff --git a/docs/testing/2026-11-17-independent-verification-acceptance.md b/docs/testing/2026-11-17-independent-verification-acceptance.md new file mode 100644 index 0000000..f693f50 --- /dev/null +++ b/docs/testing/2026-11-17-independent-verification-acceptance.md @@ -0,0 +1,94 @@ +# 独立工程校验验收记录 + +2026-11-18 已追加批量添加工程对,见[本轮验收](2026-11-18-verification-batch-import.md)。同一路径的本地开发包已更新;下文为11月17日历史结果,原EXE和证明保留在 `D:/dx-vfy-history-20261117/`。 + +开发分支:`codex/independent-verification`。独立工作目录:`.worktrees/independent-verification`。基础主线:`origin/main@b19afc6`;重新 fetch 后未出现更新提交。原工作区另一项修复仍有未提交修改,本分支没有复制它们。 + +## 已实现范围 + +| 阶段 | 结果 | +| --- | --- | +| N01~N04 | 独立任务、不可变输入版本、幂等交接、独立导入、当前版本投影、筛选/分页/计数 | +| N05~N08 | 原生只读导出、固定物理脚号判断、名称/属性警告、未知覆盖、同源接线图和逐脚事实 | +| N09~N11 | 第四导航、随时新建、开始/停止/重校验、历史版本与尝试、异步关闭、HTML/JSON报告、证据摘要与保留 | +| N12 | 混合批次、验收 CLI、真实原生导出已验证;最终默认回归、扩展回归和安装包结果见下方完成记录 | + +## 验收路径 + +受控格式路径:`python tools/verify_independent_verification.py --fixture-root <目录> --output <新目录>`。夹具目录中 `before/after` 各含合法捕获配置 `.prj` 与数据库、`effective.txt` 和 `design.kyn`。该路径明确标记 `controlled-format-fixture`,不能冒充真实 CAD 导出。 + +真实只读路径:`python tools/verify_independent_verification.py --native-before <前工程.prj> --native-after <后工程.prj> --output <新目录>`。非零退出区分异常、缺覆盖和执行失败;警告结果保留给人工确认。 + +实际执行输出:`D:/dx-vfy-native-final/acceptance.json`。前后各 57 个器件、83 个有原文定位的引脚,结论 WARNING(器件属性变化且没有固定换料清单;原生身份表另有提示)。两个工程文件及两个数据库的 SHA256 前后不变,`replacement_operations=0`。JSON、HTML、网表原文及输入摘要保留于该本地目录,Git不收录工程和厂商二进制。 + +## 验证过的关键反例 + +- R12.1/2 互换:DIFFERENT;前后图位置不随名称交换,表和报告来自相同证据。 +- loop→outloop、拓扑不变:WARNING;不伪造红色接错线。 +- 断线、短接、位号变化、物理脚号/占用次数变化、用户网名变化:硬异常。 +- 有固定清单时精确核对目标属性;无清单时列出变化并注明“未核对换料规则”。 +- 缺必查字段/库映射:INCOMPLETE;硬异常与未知同时存在时仍为 DIFFERENT。 +- 重复/乱序交接不重复创建;旧版本结果只留历史;重校验不会沿用旧绿灯。 +- 持久停止先于提交时取消获胜;终态先提交时保留真实结果;未派发项回到待校验。 +- 原始证据损坏取消绿色结论并拒绝有效报告;清历史不删除证据;存储失败暂停执行器。 +- 慢证据核验不占住数据库事务,新建任务可继续;同一尝试仅一个领取者。 +- 关闭可重复调用;重启不自动重跑;退出缺证明保留现场,不按 PID 误杀其他进程。 + +## 视觉检查 + +实际 Qt 截图而非生图:本机 `F:/dx-vfy-preview-20261117/`。1280×880、980×700,以及 1.25/1.5 缩放均已生成检查。接线图使用自建 R12 反脚夹具演示,不能冒充真实工程错误。完整事实另有逐脚表和原文定位。 + +## 验证环境与限制 + +共享 `.venv` 的基础 Python 路径异常,导致 `-E/-I` 的旧进程边界测试失败;Windows 默认 GBK 还影响旧测试中未声明编码的读取。没有修改产品旧执行器或用户环境变量。独立验证环境为 `D:/dx-vfy-python-20261117`,基于本机已安装 Python 3.12.10,复用已安装依赖;测试使用进程级 `-X utf8`。 + +首次默认回归:2221 passed、6 failed、6 errors;其中关闭重复调用的本功能回归已修复,环境相关项在独立环境的相关 66 项测试中通过。首次扩展回归 818 passed、4 failed、4 skipped;本功能首选问题定位已修正,GBK 相关的 28 项复核通过。不能把首轮失败记录解释为最终全绿结果。 + +F 盘空间不足使第一次构建未完成;仅清理了本工作目录本次生成的失败构建目录,构建和后续测试转到 D 盘。没有清理原工作区、客户工程或其他任务输出。引脚级 Value、确切库内部引脚到焊盘映射、ERC/PCB 正确性仍未覆盖。 + +## 最终完成记录 + +N01~N12 的新增功能已完成并提交到独立分支,本次交付本地开发包,不合并、不推送、不发布。原工作区另一任务的未提交修复未改动。 + +### 测试结果 + +| 范围 | 实际结果与证据 | +| --- | --- | +| 全部新增服务/Qt/验收组(16 个测试文件) | **81 passed**,`D:/dx-vfy-new-final81.xml`;包含慢读取不饿死、100行分页保持、刷新保留问题选择 | +| DSH 与打包扩展组 | **476 passed, 1 skipped**;跳过项是未配置官方 7-Zip 的自解压验证 | +| 默认范围分段及相关复核 | 当前收集 **2250** 项,均能在通过的分组记录中找到,`missing=[]`;`D:/dx-vfy-regression-coverage.json` | +| 一次连续默认全量稳定全绿 | **未取得**;不能用分组覆盖替代。此前运行及复核记录保留如下 | + +新增组命令:使用 `D:/dx-vfy-python-20261117/Scripts/python.exe -X utf8 -m pytest`,逐项传入 `tests/v1_1/test_independent_verification_{contracts,store,intake,queries,runner,rules,acceptance}.py`、`tests/v1_1/test_verification_{pin_metadata,evidence,control,reports}.py`、`tests/ui/test_verification_{workspace,inspector,control,report_actions,acceptance}.py`(花括号表示文件集合,实际使用完整文件名),参数 `-q --basetemp D:/dx-vfy-tests-final81 --junitxml D:/dx-vfy-new-final81.xml`。扩展组命令为同一解释器执行 `-m pytest tests/dsh tests/packaging -q`。 + +默认范围证据:`D:/dx-vfy-default-complete.xml`(1496 passed、1 failed)、`D:/dx-vfy-default-tail.xml`(746 passed、1 failed、1 teardown error)。失败分别涉及既有 safe-user-stop 的真实 supervisor 启动见证超时,以及 history 搜索精确 250ms 的定时边界;相应文件未改,独立复核 `D:/dx-vfy-legacy-stop.xml` 为 **34 passed**。既有 VBS 超时组单独复核 **5 passed**。这些波动仍是发布前需要处理的事项,不在本次新增功能中改写旧逻辑或放宽断言。 + +覆盖审计只收集当前默认用例、与各 XML 的实际 passed 节点集合比较,不运行或跳过测试;证据集合为上述两份默认记录、新增81项及34项复核,`continuous_full_run_green=false`。审计脚本 `D:/vfy_audit_coverage.py`。 + +### 实际包验收 + +开发包:`D:/dx-vfy-release-20261117/DxPartReplace/DxPartReplace.exe`(须保留同目录完整 `_internal`)。源码提交 `f91b4de`;EXE SHA256:`9aeea5d8fb1263b1da32d5d0363a2f9cd6310d884c41a45c44debb4bf3fb8fb3`。随后只更新验收文档,不改变包内源码。 + +完整运行时由仓库标准 spec 构建。最终 Python 修改通过官方 PyInstaller PYZ/EXE API 重新编译并原子替换 EXE,复用该次已完成且未改变的原生/Node运行时,未修改厂商内容。可复核脚本为 `D:/verification-code-refresh.spec`;`D:/vfy_verify_archive.py` 实际逐个比较归一化路径后的 Python 代码对象,**22 个变更源码模块与最终包完全一致**,无 mismatch,证明保存在 `D:/dx-vfy-package-proof.json`。 + +| 实际操作 | 结果与现场 | +| --- | --- | +| 四导航、连续新建两个独立任务 | 通过,`D:/dx-vfy-package-ui-v2/acceptance.json` | +| 使用真实系统文件选择器添加前后工程并开始 | 原生导出完成、WARNING、输入四文件摘要不变、换料操作数0、正常退出,`D:/dx-vfy-package-pair-v5/acceptance.json` | +| 包内重校验 | generation 2、WARNING;PID+进程创建时间归属证明成立、换料操作数0、正常退出,`D:/dx-vfy-package-final-rerun/acceptance.json` | +| 最终包重启并查看已有结果 | 右侧真实接线图与“input · 需关注”加载完成;attempt数仍为2、不自动执行、换料操作数0、退出码0,`D:/dx-vfy-package-final-view/acceptance.json` | +| 最终包运行时/正常关闭 | frozen supervisor、win32timezone、创建时间读取及资源释放均通过;`tools/verify_packaged_runtime.py` 对新数据根 `D:/dx-vfy-package-smoke-delivery` 的实际结果 | + +最终包截图:`D:/dx-vfy-package-final-view/native-result-final.png`。该图使用真实导出的工程结果,不能把较早在读取完成前抓到的待校验画面当成最终证据。反脚效果仍使用明确标注的自建 R12 夹具;没有改写客户工程制造错误。 + +### 操作与恢复细节 + +工程表每页100项,“下一页”有界读取;周期刷新保留当前页,筛选回第一页,开始全部不受分页影响。周期刷新等待当前查询完成,保留多选、问题选择和事实滚动位置,用户显式切换仍使用代际取消。切任务清空旧检查器,关闭先失效旧查询。 + +`verification/ownership.py` 用 PID 和创建时间证明校验窗口归属,保护另一窗口仍活跃的执行;调度仅处理本实例运行,停止请求持久化。进程已经退出但缺少原生CLI退出证明时仍保持资源未知;不猜测退出、不按PID杀进程、不自动重跑。资源失败原因随尝试保存。 + +成功交接与增量接口已通过受控真实SQLite/服务集成测试;本次包内真实验证走独立两份工程路径,没有为制造新回执再执行客户换料。未来替换实时推送不在本轮范围。 + +### 保留边界 + +引脚级 Value、确切封装库内部脚位到焊盘映射未得到来源证明,明确未覆盖;ERC/PCB及自动修复不属于本功能。默认连续全量时序稳定性尚未满足发布门槛。以上限制不以网表一致或执行完成掩盖。 diff --git a/docs/testing/2026-11-18-verification-batch-import.md b/docs/testing/2026-11-18-verification-batch-import.md new file mode 100644 index 0000000..0149da0 --- /dev/null +++ b/docs/testing/2026-11-18-verification-batch-import.md @@ -0,0 +1,41 @@ +# 批量添加工程对验收 + +分支 `codex/independent-verification`,功能提交 `eda9403`,拒收回执修正 `de16bbd`。2026-11-18 重新 fetch 后,主线仍为 `b19afc6`。本轮只补批量导入,不修改另一任务的既有执行器修复。 + +## 已实现 + +- 第四页新增“批量添加”,打开非模态窗口,仍能新建其他校验任务。 +- 读取两个独立根目录,沿用已有只读目录扫描规则,按相对路径精确配对;不按同名文件猜测对应关系。缺失、不唯一的项列出且不能勾选。 +- 勾选后逐对建立冻结副本,列表与报告保留相对路径名称;同名工程可区分。导入不会启动网表校验或换料。 +- 单项失败后继续,取消保留已导入项;同一批请求可续传且不重复建项。请求取消后仍绑定原始输入,不允许用相同请求标识替换内容。 +- 磁盘/存储故障中断整批;任务库拒收单项时明确显示失败,不把函数返回等同于导入成功。超过256字符的批量名称提示缩短层级或逐对添加。 +- 扫描、复制在后台执行;关闭窗口取消操作,晚到结果不回写已关闭界面,应用关闭协作沿用现有控制器。 + +## 自动化验证 + +| 范围 | 实际结果 | +| --- | --- | +| 原独立校验组与本轮两份新测试文件,共18文件 | **92 passed**,`D:/dx-vfy-batch-final.xml` | +| 既有关闭生命周期 `tests/ui/test_deferred_close_lifetime.py` | **2 passed**,`D:/dx-vfy-batch-close.xml` | +| 最终包运行时、supervisor、创建时间、关闭与资源释放 | 通过;`tools/verify_packaged_runtime.py`,数据根 `D:/dx-vfy-batch-smoke-20261118` | + +本轮新增11项测试覆盖相对路径/缺失、根目录重叠、失败后继续、重复请求、取消续传、存储耗尽、输入绑定、拒收回执,以及Qt勾选导入、并行新建和关闭读取。先确认缺失接口、请求复用及误报成功的反例失败,再实现并复跑。 + +解释器为 `D:/dx-vfy-python-20261117/Scripts/python.exe -X utf8`。新文件为 `tests/v1_1/test_verification_batch_import.py` 与 `tests/ui/test_verification_batch_import.py`,与[前轮验收](2026-11-17-independent-verification-acceptance.md)的16文件校验组一起执行,使用独立D盘临时目录,没有放宽旧断言。 + +本轮未重新执行全部默认测试。当前默认收集2261项,在已留存的分组通过记录中均有覆盖,`missing=[]`,`D:/dx-vfy-batch-regression-coverage.json`。这属于历史分组覆盖审计,不代表新取得一次连续全量全绿;前轮记录的既有时序波动仍保留。 + +## 实际开发包 + +更新包:`D:/dx-vfy-release-20261117/DxPartReplace/DxPartReplace.exe`,保留同目录 `_internal`。EXE SHA256:`56ba31c71f61aafed0bdeab88026112adc7362c4a037d94a783cfddb5959a24f`。仍使用前轮完整标准构建的原生运行时,通过官方PyInstaller API重新编译Python代码;`D:/verification-code-refresh.spec` 显式包含新增两个模块。 + +实际解包与源码代码对象比较:**24个变更模块匹配,无 mismatch**;`D:/dx-vfy-package-proof.json`,复核脚本 `D:/vfy_verify_archive.py`。前轮EXE及证明另存 `D:/dx-vfy-history-20261117/`,避免覆盖历史证据。 + +通过外部Windows UI操作实际EXE,新建任务、点击“批量添加”、填写前后目录、读取配对、导入所选、返回任务、正常关闭。输入是既有已保存工程的复制件,包含两个同名工程对及一项缺失: + +- `A/input.prj`、`B/input.prj` 正确导入,`orphan/input.prj` 因缺少修改后工程未导入。 +- 校验尝试数0、换料操作数0,所有输入文件摘要不变,退出码0。 +- 实际操作证明 `D:/dx-vfy-batch-package-20261118/acceptance.json`;预览截图 `batch-preview.png`、完成截图 `batch-imported.png`、任务截图 `batch-workspace.png` 在同目录。 +- 测试脚本 `D:/vfy_packaged_batch.py` 只通过Windows可访问性接口操作应用窗口,再查询持久结果;没有直接注入任务状态。主窗口PrintWindow截图的灰底来自默认透明材质捕获,不据此改动既有全局UI。 + +批量导入仅覆盖目录结构对应的输入登记;本轮未重新执行真实原生网表导出。引脚级Value、确切库内脚到焊盘映射仍按前轮明确未覆盖。未合并、推送或发布。 diff --git a/docs/testing/2026-11-18-verification-closed-loop.md b/docs/testing/2026-11-18-verification-closed-loop.md new file mode 100644 index 0000000..33459fa --- /dev/null +++ b/docs/testing/2026-11-18-verification-closed-loop.md @@ -0,0 +1,53 @@ +# 工程校验闭环验收(2026-11-18) + +后续剩余四项已完成,最新状态见[最终闭环验收](2026-11-18-verification-final-closure.md)。本文保留当时的原始范围与未测记录,不作为最新缺口清单。 + +按[闭环标准 v1](verification-closed-loop-standard.md)补齐 N12。代码与工具提交 `e65bed0`,分支 `codex/independent-verification`。本次没有修改另一修复任务的旧执行器,没有合并、推送或发布。 + +## 实现与标准 + +新增 `tools/verification_closed_loop.py`:开始前冻结范围、源文件摘要和换料操作基线,逐项检查实际运行成员、终态、预期结论、输入/尝试/策略绑定、原文摘要、资源退出证明与报告。空任务、漏项、停止/中断、错误预期、旧报告或源文件变化不能通过。 + +HTML报告增加 item、attempt、generation、输入版本/摘要和证据摘要的可核对绑定。已有换料历史允许保留;只读标准检查运行前后计数不变,而非历史总数必须为0。整任务报告中只验证选定项时必须明确指定范围,其余项不冒充已验证。 + +单次服务验收入口 `tools/verify_independent_verification.py` 增加 `--expect-verdict`,默认 CONSISTENT;预期警告应事先传 WARNING。输出 `frozen-scope.json` 和 `closed-loop.json`,检查不通过非零退出。它明确只覆盖 C01~C05,C06~C08 保留 not_run。 + +实际包入口 `tools/accept_verification_closed_loop.py` 通过Windows可访问性操作EXE,公开服务和SQLite用于读取及核对,不直接注入执行状态。必须事先给出预期名单和结论;`--fault-batch` 在私有复制件中加入明确无效的数据库反例,原输入目录不改写。 + +## 实际通过范围 + +| 场景 | 结果 | 证据 | +| --- | --- | --- | +| 两份真实保存副本批量导入、原生执行、查看、报告、重启、重校验 | C01~C07通过,两个 WARNING 符合事先指定的预期;重校验后尝试为1、1、2,旧结果和报告不变 | `D:/dx-vfy-loop-package-20261118-v2/acceptance.json`,16条检查通过 | +| 首项原生失败,后续两个真实保存副本继续 | 00-invalid 为 failed/INCOMPLETE,随后 A、B 均完成 WARNING;混合报告、重启和A单项重校验通过 | `D:/dx-vfy-loop-faults-20261118-v2/acceptance.json`,17条检查通过 | +| 只读与正常关闭 | 两个现场的所有记录输入摘要不变,换料操作数0;所有测试实例正常关闭,未按PID杀进程 | 各现场 JSON、应用正常退出日志和资源退出证明 | +| 校验功能组 | 104 passed,19个测试文件 | `D:/dx-vfy-loop-final.xml` | +| 闭环选定范围补充复核 | 19 passed,覆盖本轮验收器、CLI和报告 | `D:/dx-vfy-loop-scope.xml` | + +第二现场的失败项是自建无效数据库,证据类型 `native-real-copies-and-invalid-database-fixture`。它证明真实原生导出失败后的隔离行为,不能冒充真实客户工程反脚。物理脚互换、断线、短接、loop→outloop、必查未知等判断仍由明确标注的受控服务/Qt反例验证。 + +各现场保存 `01-pairs.png`、`02-result.png`、`03-restart.png`、`frozen-scope.json`、`first-run.json`、`restart-readback.json`、`rerun.json` 和两个不可覆盖的报告目录。重校验报告绑定新attempt,原报告摘要未变。 + +## 可复现命令 + +使用本机独立验证环境,下面的输入目录是前轮保存副本,不是源工程;输出必须为新目录。 + +```powershell +& 'D:/dx-vfy-python-20261117/Scripts/python.exe' -X utf8 tools/accept_verification_closed_loop.py --exe D:/dx-vfy-release-20261117/DxPartReplace/DxPartReplace.exe --before-root D:/dx-vfy-batch-package-20261118/before --after-root D:/dx-vfy-batch-package-20261118/after --expected-items A/input.prj B/input.prj --expect-verdict WARNING --output D:/NEW-normal-loop +``` + +加入 `--fault-batch` 并换用新输出目录,可重复故障隔离场景。工具只在自己的输出目录复制输入并生成 `00-invalid`,该名称为反例保留名。 + +测试使用同一解释器 `-X utf8 -m pytest`,原18文件校验组增加 `tests/v1_1/test_verification_closed_loop.py`,参数 `-q --basetemp D:/dx-vfy-loop-delta-final --junitxml D:/dx-vfy-loop-final.xml`。补充复核为 `tests/v1_1/test_verification_closed_loop.py tests/v1_1/test_independent_verification_acceptance.py tests/v1_1/test_verification_reports.py`,输出 `D:/dx-vfy-loop-scope.xml`。 + +## 包身份与失败现场 + +本地开发包仍位于 `D:/dx-vfy-release-20261117/DxPartReplace/DxPartReplace.exe`,须保留同目录 `_internal`。本轮EXE SHA256为 `c52c43d8b4a864b85f0a39b92a5b3aab2bc36095240d42968d2d34971c270a91`。复用此前标准构建的未变原生运行时,通过官方PyInstaller API重新编译Python;`D:/vfy_verify_archive.py` 对本分支24个变更模块逐个比较代码对象,全部一致,记录 `D:/dx-vfy-package-proof.json`。上一批量版EXE和证明保留在 `D:/dx-vfy-history-20261118-batch/`。 + +失败记录保留:首个正常现场因自动化误用文件选择器而无法操作目录选择器;首个故障现场在重启等待中触发驱动内部15秒超时。已依据真实控件ID修正目录选择器,并让外层90秒等待正确处理内部超时;没有改产品文件对话框或伪造结果。旧现场分别为 `D:/dx-vfy-loop-package-20261118/`、`D:/dx-vfy-loop-faults-20261118/`,测试实例均正常关闭。通过结果来自修正后的全新目录,不是改写旧失败记录。 + +## 未测与发布门槛 + +仍未取得实际包中停止/资源未知的独立故障现场;其服务/Qt受控回归已通过。真实成功换料回执触发自动交接的包内闭环尚未测,不能用独立输入替代;本轮没有为此重新执行客户换料。连续默认全量没有重跑,前轮既有时序波动仍未解决。因此本次只证明上表范围,未达到发布门槛。 + +引脚级Value、确切封装库内部脚位到焊盘映射仍未覆盖,不能从网表校验推断这些能力通过。后续按计划中未勾选项推进。 diff --git a/docs/testing/2026-11-18-verification-final-closure.md b/docs/testing/2026-11-18-verification-final-closure.md new file mode 100644 index 0000000..c915d38 --- /dev/null +++ b/docs/testing/2026-11-18-verification-final-closure.md @@ -0,0 +1,59 @@ +# 剩余四项闭环验收 + +执行分支 `codex/independent-verification`,验收工具与回归提交 `b038951`。按[确认的剩余计划](../superpowers/plans/2026-11-18-verification-remaining-closure.md)顺序执行,未修改其他修复工作区,未合并、推送或发布。 + +**剩余四项均已取得对应闭环证据。** 停止/恢复、资源未知保护、真实已保存回执自动交接,以及固定提交上的连续默认全量均通过;此前历史记录中的未测状态以本文更新为准。 + +## 业务闭环现场 + +| 项目 | 已验证的实际行为 | 现场 | +| --- | --- | --- | +| 三工程停止与继续 | 第一项运行时点击停止;两项未派发保持待校验;重启不自动运行;开始全部只继续这两项,已停止项明确重校验;最终三项均WARNING,旧停止记录保留 | `D:/dx-vfy-stop-three-20261118/acceptance.json` | +| 自有实例异常退出 | 核对PID、创建时间与owner后仅中断本工具启动的实例;没有原生退出证明时重启保留stopping/unknown,不显示有效结论、不给后续项创建导出目录 | `D:/dx-vfy-owner-exit-register-20261118/acceptance.json` | +| 资源未知下可用性 | 可新建另一任务并导入两项;共4输入、仍只有原来的2次尝试;暂停原因在“检查与范围”中实际可见,应用正常关闭 | 同目录 `reason-visible.json`、`resource-unknown-reason.png` | +| 真实保存回执自动交接 | 临时副本RV05从4100-CA0000-T7到4100-CA0000-T0,RV11保持;恰好一条verified换料记录,自动交接只有一个工程项 | `D:/dx-vfy-real-handoff-20261118-v2/acceptance.json` | +| 交接后校验、报告、重启与重校验 | 两次尝试generation 1/2,均WARNING;声明属性为expected_change,物理脚/连接/位号/覆盖/网名等必查equal;14条闭环检查通过,换料记录完整内容未变,重复交接未重复建项 | 同目录 `verification-loop/acceptance.json` | + +所有只读校验现场的输入摘要再次核对未变。真实换料只发生于新测试副本,原始样例及共享库LMC摘要仍与执行前一致。资源未知现场按设计保留,不补造退出证明;测试应用实例均已退出。 + +预期在开始前保存:停止/异常场景的 `frozen-scope.json`,真实换料的 `predeclared.json`。后者先真实原生导出证明RV05/RV11前提,再准备BOM并通过实际EXE点击确认执行;无直接SQLite写入来伪造换料结果。 + +停止现场有 `continued.json`、`stopped-item-rerun.json` 和各自报告。真实交接有确认截图、自动交接截图、原生before/after、不可变快照、实际运行回执、报告以及重启截图。未知资源场景有本工具记录的owner身份和界面截图,未终止其他进程。 + +## 实现与验证边界 + +新增控制场景验收检查器和真实交接验收工具;`accept_verification_closed_loop.py` 增加 `--control-scenario stop|owner-exit`、`--handoff-data`。产品没有新增故障开关,也没有更改旧换料执行器。 + +真实交接的before是历史不可变快照,替换保存后,其原路径自然已有新内容。验收器仅在明确的 `historical_before=True` 且存在预期清单时使用历史快照证明before,以after源摘要作为后续校验只读基线,不重新捕获旧before。普通独立导入仍检查源文件未偏离导入版本。 + +只读检查增加执行日志摘要,除了记录数不变,还要求原有command、receipt和generation不变;相应反例已先失败再修正。真实实际包外层另外比较校验前后全部换料记录,证明不会原地重放已有操作。 + +针对验收器/控制/CLI/报告的相关回归:**22 passed**,`D:/dx-vfy-final-closure-related.xml`。 + +第一次连续默认全量:**2276 passed,0 failures,0 errors**,`D:/dx-vfy-continuous-default-20261118.xml`,耗时1214.45秒。此轮启动后补充过验收器的日志摘要反例,因此仍追加在固定提交 `b038951` 上的最终全量运行,不把首轮当作最终固定测试版本的全部证据。 + +执行恢复/回执及打包扩展:**120 passed,1 skipped**,`D:/dx-vfy-final-closure-extended.xml`。范围为 `tests/dsh/test_execution_recovery.py`、`test_run_journal.py`、`test_large_execution_scope.py` 和 `tests/packaging`;跳过的是未配置官方7-Zip的自解压验证。 + +固定提交上的最终默认全量:**2276 passed,0 failures,0 errors,0 skipped**,输出 `D:/dx-vfy-fixed-default-20261118.xml`,耗时1271.60秒。启动前记录631个已跟踪产品/测试/工具文件的SHA256:`D:/dx-vfy-fixed-default-20261118-manifest.json`;结束后实际复核全部不变。它与第一轮分开留证,不能用历史分组覆盖代替。 + +两轮均只有pywinauto的STA COM线程模式提示,没有失败或错误。本轮未改写旧测试的时序断言;当前完整回归通过不等于声称根治所有环境中的历史时序波动。 + +第一次真实交接现场 `D:/dx-vfy-real-handoff-20261118` 因自动化尚未选择任务导致执行按钮不可用,记录失败并正常关闭,换料操作数0。修正测试驱动为先选择任务,再使用全新v2副本完成实际执行;没有对已替换副本重复派发。 + +## 包身份 + +仍使用 `D:/dx-vfy-release-20261117/DxPartReplace/DxPartReplace.exe` 和完整 `_internal`。EXE SHA256:`c52c43d8b4a864b85f0a39b92a5b3aab2bc36095240d42968d2d34971c270a91`。本轮只改验收工具、测试和文档,产品代码没有改变,无需重新构建。 + +`D:/vfy_verify_archive.py` 已对本分支24个变更产品模块逐个比较最终包代码对象,全部匹配。身份记录 `D:/dx-vfy-package-proof.json`。校验源码与包的一致性不能替代厂商工具或库内部能力验证。 + +最终运行时复核通过:`tools/verify_packaged_runtime.py` 对全新数据根 `D:/dx-vfy-final-closure-runtime-20261118` 验证frozen supervisor、win32timezone、进程创建时间、正常退出和资源释放,均为true。开发包保持原SHA256。 + +## 复现入口 + +使用 `D:/dx-vfy-python-20261117/Scripts/python.exe -X utf8`,工作目录为本分支。所有输出目录必须新建且不能位于源工程/库内。 + +- 停止/异常退出:`tools/accept_verification_closed_loop.py --exe --before-root <前目录> --after-root <后目录> --expected-items A/input.prj B/input.prj C/input.prj --expect-verdict WARNING --control-scenario stop --output <新目录>`;未知资源用 `owner-exit`,至少保留两项供未派发检查。 +- 真实交接:`tools/accept_verification_saved_handoff.py --source <原始已保存工程.prj> --library <已安装库.lmc> --exe --output <新目录>`;固定RV05/RV11和料号前提不满足时失败,不临时换测试目标。 +- 连续默认全量:`-m pytest -q --basetemp D:/dx-vfy-fixed-default-20261118-long-temporary-root --junitxml D:/dx-vfy-fixed-default-20261118.xml`;重复执行须换用全新临时根和XML文件,保留本次原始记录。 + +引脚级Value和确切封装库内部映射仍未覆盖,不属于四项验收缺口,也未宣称完成ERC/PCB验证。官方7-Zip缺失导致的自解压安装包检查仍为skip;本轮交付已验证的本地开发包,没有制作、合并或发布新安装包。 diff --git a/docs/testing/verification-closed-loop-standard.md b/docs/testing/verification-closed-loop-standard.md new file mode 100644 index 0000000..94fb9b6 --- /dev/null +++ b/docs/testing/verification-closed-loop-standard.md @@ -0,0 +1,35 @@ +# 工程校验闭环标准 v1 + +本标准用于 N12 及后续功能。写完代码、测试通过、工程检查一致、业务闭环通过、允许发布,是不同结论。每次验收必须声明正在证明哪一个结论。 + +## 单次功能闭环的通过条件 + +| 编号 | 必须证明 | 不满足时 | +| --- | --- | --- | +| C01 输入冻结 | 开始前写下预期工程名单、数量、前后摘要、输入版本和检查策略;配对预览与实际导入相符 | 失败;不能从运行后的结果反推预期 | +| C02 完整执行 | 用户显式开始;运行成员与冻结范围完全相同,每项都有属于本次运行的终态尝试 | 有排队、运行、停止、中断、漏项或重复项,均不能算完整闭环 | +| C03 判断正确 | 每项结论符合事先指定的预期;执行成功与 CONSISTENT/WARNING/DIFFERENT 分开;必查未知不得通过 | 误报、漏报、未知充当一致都失败 | +| C04 事实同源 | 页面、逐脚表、JSON和HTML报告绑定同一 item、输入版本、attempt、generation、输入摘要和证据摘要;原文摘要可复核 | 任何串版本、旧结果、缺证据或报告不符都失败 | +| C05 只读安全 | 校验前后全部已冻结源文件摘要不变,新增换料操作数为0,执行资源退出有证明;已有换料历史以开始前基线计数核对 | 不变性或退出证明缺失,失败并保留现场 | +| C06 重启回读 | 正常退出后重启,结果及证据仍可查看,尝试数不增加、不自动重跑 | 失败 | +| C07 重校验 | 同一输入重新执行时 attempt 更新、generation 递增;旧结果保留,新旧报告均可追溯 | 失败 | +| C08 异常隔离 | 反脚/断线等业务异常不挡后续工程;停止后未派发项仍待校验;资源/存储未知暂停正确范围;仍可新建独立任务 | 相应异常用例失败;不能以“正常样本跑过”替代 | + +只有本次要求的检查全部通过,才写“该功能闭环通过”。验证程序对失败必须非零退出;结构性检查失败不能被 WARNING、正常进程退出或成功生成文件覆盖。某项故障测试验证了预期失败,不等于故障工程已经检查通过。 + +## 固定业务反例 + +物理脚1/2互换、断线、短接、位号或物理脚号变化必须为 DIFFERENT;loop→outloop 且连接不变必须为 WARNING;必查字段缺失必须为 INCOMPLETE。图中固定物理脚号位置,异常端点可与逐脚表和原文对应。自建格式夹具用于反例和可复现测试,必须明确标注,不能当成真实CAD导出证据。 + +## 两条业务路径分别验收 + +1. 独立输入:实际开发包中批量添加 → 开始全部 → 原生导出 → 查看图表 → 导出报告 → 正常关闭 → 重启查看 → 重校验 → 再导出。 +2. 成功结果交接:真正已落盘的成功换料回执 → 自动登记校验 → 同一套执行、复核与报告。重复接收不重复建项,未保存项不得作为成功项。 + +两条路径不能互相代替。受控服务测试可证明交接合同、幂等和非阻塞;没有取得实际成功回执触发的包内证据时,该路径记“实际闭环未测”。本任务不为补验收重新执行客户换料,也不修改其他任务的旧执行器。 + +## 留证与发布 + +验收记录至少包含:代码提交、EXE SHA256、证据类型、预期清单、输入和报告摘要、任务/运行/尝试身份、每项标准的 passed/failed/not_run、失败原因、截图和实际命令。前一次运行、仅有截图、历史分组测试覆盖均不能替代本次闭环。 + +发布还要求相关回归通过、连续默认全量无未解决失败、实际包身份与源码相符、声明的两条实际路径通过。现有时序波动仍是发布保留项,不在本功能中改断言掩盖。引脚级Value和确切库内脚到焊盘映射仍未覆盖;不能写成“封装全部正确”。 diff --git a/docs/user/independent-verification.md b/docs/user/independent-verification.md new file mode 100644 index 0000000..9e2db68 --- /dev/null +++ b/docs/user/independent-verification.md @@ -0,0 +1,25 @@ +# 工程校验 + +在第四个“工程校验”页面随时新建任务。选择修改前、修改后两份已保存的 `.prj` 工程添加比较项,不能选择同一文件或共用数据库的两个工程。已有替换任务不影响新建;替换已保存的成功项会自动交接,缺少前后副本的项显示无法校验,不能用当前工程补造历史版本。 + +大量工程可点击“批量添加”,选择修改前、修改后两个根目录,再点“读取配对”。两个目录不能相同或互相包含。工具沿用工程目录扫描规则:发现含原理图工程的目录后,不再扫描其子目录;数据目录不参与扫描。 + +配对只认相对路径,例如前目录的 `Board-A/board.prj` 对应后目录的 `Board-A/board.prj`;不同子目录中同名工程不会混配。预览列出缺失或无法唯一配对的项,它们不能勾选。不符合这个目录结构的工程,仍可用“添加工程对”逐对指定。 + +批量导入后,任务内保留这个相对路径作为工程名称,列表、历史和报告中都能区分不同目录里的同名工程。 + +批量名称沿用任务库的 256 字符上限;相对路径超过上限时该项显示导入失败,可缩短目录层级或使用“添加工程对”单独添加。不会把任务库拒收误报成导入成功。 + +勾选后点“导入所选”,只建立前后只读副本,随后回到任务点击“开始全部”或“校验所选”。单项导入失败后继续其他项,失败原因保留在状态提示中;取消或关闭导入窗口时保留已导入项,未处理项可继续选择导入。磁盘空间或存储故障会中断整批并保留已导入项。此窗口不阻止新建其他校验任务。 + +“开始全部”处理当前任务中当时待校验/中断的工程;筛选不会缩小这个范围。“校验所选”和“重校验”明确处理所选工程当前版本。运行期间后到的新项或新版本留待下次开始。校验只读副本,不会重新换料或自动换脚。 + +工程表每页最多显示 100 项,点击“下一页”继续查看;自动刷新保留当前页,修改搜索或筛选后回到第一页。分页和筛选都不影响“开始全部”的范围。 + +一致表示已覆盖的必查项未发现差异;需关注表示有文字或属性变化需要人工判断;异常表示已证明位号、物理脚号、连接或声明目标等不符合;无法校验表示证据不足。没有固定换料清单时始终显示“未核对换料规则”。执行结束不等于工程一致。 + +选择工程,在右侧选择位号查看固定脚号的前后接线图和逐脚事实。红线对应连接变化;纯名称变化以关注提示。图由网表生成,不是原理图截图。原始证据入口会核对摘要;历史版本仅供查看,不改变当前结论。导出报告包含同一份图表、检查范围、输入和尝试摘要,不复制整个工程。 + +停止采用安全收尾。未派发项保留待校验,已开始项保留停止记录。重启不会自动重跑;缺少进程退出证明的项保留现场并暂停新的原生导出,不按 PID 猜测或终止其他进程。 + +首版未证明引脚级 Value 读取和确切库内部引脚→焊盘映射,页面明确未覆盖。电气类型按原生码展示,不臆造语义。本网表比较不宣称完成 ERC、PCB 或封装库内部正确性验证。普通操作历史清空和运行日志保留不会删除校验快照与证据。 diff --git a/src/dx_productivity/dsh/execution_runs.py b/src/dx_productivity/dsh/execution_runs.py index ae488a0..67f816f 100644 --- a/src/dx_productivity/dsh/execution_runs.py +++ b/src/dx_productivity/dsh/execution_runs.py @@ -152,6 +152,20 @@ 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: + from ..trial_task_center.verification.contracts import digest + delivery = verification.receive_successful_results( + receipt, submission_id=f'run:{run_id}:{digest(receipt)}') + if delivery['rejected']: + receipt['reporting_errors'].append({'code': 'verification_delivery_pending', + 'rejected': delivery['rejected']}) + 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 b91d840..e3af849 100644 --- a/src/dx_productivity/trial_task_center/service.py +++ b/src/dx_productivity/trial_task_center/service.py @@ -102,6 +102,14 @@ def _default_path_opener(path: Path) -> None: class TaskCenterService: """The only API used by UI workers and widgets.""" + @property + def verification(self): + with self._store._lock: + 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/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/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 1f2ef66..97b3f1d 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() @@ -400,6 +409,12 @@ class TrialTaskCenterWindow(MaterialMainWindow): self._dsh_view.stopped.connect(lambda: QTimer.singleShot(0, self, self.close)) self._dsh_view.shutdown() return + if self.verification_panel.busy: + self._close_pending = True + self.verification_panel.begin_shutdown() + event.ignore() + QTimer.singleShot(100, self.close) + return self._cancel_dsh_diagnosis() for name, widget in self._layout_widgets().items(): self._layout_settings.setValue(f'single_project/{name}', widget.saveState()) @@ -408,6 +423,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/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_batch_import.py b/src/dx_productivity/trial_task_center/ui/verification_batch_import.py new file mode 100644 index 0000000..700bbe0 --- /dev/null +++ b/src/dx_productivity/trial_task_center/ui/verification_batch_import.py @@ -0,0 +1,187 @@ +"""Nonmodal preview and sequential import of saved project pairs.""" +from threading import Event +from uuid import uuid4 + +from PySide6.QtCore import QObject, Signal, Qt +from PySide6.QtWidgets import (QDialog, QFileDialog, QHeaderView, QHBoxLayout, QLabel, + QLineEdit, QPushButton, QTableWidget, QTableWidgetItem, QVBoxLayout) + + +LABELS = {'ready': '可导入', 'missing_before': '缺少修改前工程', 'missing_after': '缺少修改后工程', + 'ambiguous': '无法唯一配对', 'imported': '已导入', 'failed': '导入失败,可重试'} + + +class _Progress(QObject): + changed = Signal(object, int, int) + + +class VerificationBatchDialog(QDialog): + changed = Signal() + + def __init__(self, service, controller, task_id, task_name, parent=None): + super().__init__(parent) + self.service, self.controller, self.task_id = service, controller, task_id + self._phase = None + self._closed = False + self._stop = Event() + self._rows = [] + self._selection = [] + self.setWindowTitle('批量添加工程对') + self.resize(860, 540) + layout = QVBoxLayout(self) + title = QLabel(f'添加到:{task_name}') + title.setWordWrap(True) + layout.addWidget(title) + explanation = QLabel('按两个目录中的相对路径精确配对;先预览再导入。只建立只读副本,不自动开始校验。') + explanation.setWordWrap(True) + layout.addWidget(explanation) + self.before = QLineEdit(objectName='verificationBeforeRoot') + self.after = QLineEdit(objectName='verificationAfterRoot') + self._browsers = [] + for label, field in (('修改前目录', self.before), ('修改后目录', self.after)): + row = QHBoxLayout() + row.addWidget(QLabel(label)); row.addWidget(field, 1) + browse = QPushButton('选择目录') + browse.clicked.connect(lambda _, f=field: self._browse(f)) + self._browsers.append(browse); row.addWidget(browse) + layout.addLayout(row) + field.textChanged.connect(self._invalidate) + actions = QHBoxLayout() + self.scan = QPushButton('读取配对', objectName='verificationScanPairs') + self.select_all = QPushButton('全选可导入项') + self.select_none = QPushButton('清空选择') + for button in (self.scan, self.select_all, self.select_none): actions.addWidget(button) + actions.addStretch(); layout.addLayout(actions) + self.table = QTableWidget(0, 4, objectName='verificationPairPreview') + self.table.setHorizontalHeaderLabels(['工程相对路径', '修改前工程', '修改后工程', '状态']) + self.table.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers) + self.table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Stretch) + layout.addWidget(self.table, 1) + self.summary = QLabel('选择前后目录后读取配对。'); self.summary.setWordWrap(True) + layout.addWidget(self.summary) + bottom = QHBoxLayout() + self.import_button = QPushButton('导入所选', objectName='verificationImportPairs') + self.cancel_button = QPushButton('取消当前操作') + close_button = QPushButton('关闭') + bottom.addWidget(self.import_button); bottom.addWidget(self.cancel_button); bottom.addStretch(); bottom.addWidget(close_button) + layout.addLayout(bottom) + self.scan.clicked.connect(self._scan) + self.select_all.clicked.connect(lambda: self._select(Qt.CheckState.Checked)) + self.select_none.clicked.connect(lambda: self._select(Qt.CheckState.Unchecked)) + self.table.itemChanged.connect(self._selection_changed) + self.import_button.clicked.connect(self._import) + self.cancel_button.clicked.connect(self.cancel_operation) + close_button.clicked.connect(self.reject) + self._gates() + + @property + def busy(self): return self._phase is not None + + def _browse(self, field): + selected = QFileDialog.getExistingDirectory(self, '选择工程根目录', field.text()) + if selected: field.setText(selected) + + def _invalidate(self): + if not self.busy: + self._rows = []; self.table.setRowCount(0) + self.summary.setText('目录已改变,请重新读取配对。'); self._gates() + + def _selected(self): + return [n for n, row in enumerate(self._rows) if row['status'] in ('ready', 'failed') + and self.table.item(n, 0).checkState() == Qt.CheckState.Checked] + + def _gates(self): + for widget in (self.before, self.after, *self._browsers, self.select_all, self.select_none, self.table): + widget.setEnabled(not self.busy) + self.scan.setEnabled(not self.busy and bool(self.before.text().strip()) and bool(self.after.text().strip())) + self.import_button.setEnabled(not self.busy and bool(self._selected())) + self.cancel_button.setEnabled(self.busy and not self._stop.is_set()) + + def _select(self, state): + for n, row in enumerate(self._rows): + if row['status'] in ('ready', 'failed'): self.table.item(n, 0).setCheckState(state) + + def _selection_changed(self): + if not self.busy: + self.summary.setText(f'共 {len(self._rows)} 项,已选 {len(self._selected())} 对;缺失或不唯一的项目不会导入。') + self._gates() + + def _scan(self): + before, after = self.before.text().strip(), self.after.text().strip() + self._phase = 'scan'; self._stop = Event(); self._rows = []; self.table.setRowCount(0) + self.summary.setText('正在读取前后目录…'); self._gates() + stop = self._stop + self.controller.command(lambda: self.service.preview_pairs(before, after, stop_event=stop), self._scanned, self._failed) + + def _scanned(self, rows): + self._phase = None + if self._closed: return + self._rows = rows + self.table.blockSignals(True) + try: + self.table.setRowCount(len(rows)) + for n, row in enumerate(rows): + for col, value in enumerate((row['relative_path'], row['before'] or '—', row['after'] or '—', LABELS[row['status']])): + item = QTableWidgetItem(value); item.setToolTip(value) + if col == 0: + item.setCheckState(Qt.CheckState.Checked if row['status']=='ready' else Qt.CheckState.Unchecked) + if row['status']!='ready': item.setFlags(item.flags() & ~Qt.ItemFlag.ItemIsUserCheckable) + self.table.setItem(n, col, item) + finally: self.table.blockSignals(False) + self._selection_changed() + + def _import(self): + self._selection = self._selected() + pairs = tuple((self._rows[n]['before'], self._rows[n]['after']) for n in self._selection) + names = tuple(self._rows[n]['relative_path'] for n in self._selection) + self._phase = 'import'; self._stop = Event() + self.summary.setText(f'正在导入 0/{len(pairs)} 对…'); self._gates() + progress = _Progress(self); progress.changed.connect(self._progress) + stop, request = self._stop, uuid4().hex + self.controller.command(lambda: self.service.import_pairs(self.task_id, pairs, request_id=request, + stop_event=stop, on_progress=progress.changed.emit, display_names=names), self._imported, self._failed) + + def _progress(self, row, processed, total): + if self._closed: return + n = self._selection[row['index']] + self._rows[n]['status'] = row['status'] + status = self.table.item(n, 3) + status.setText(LABELS[row['status']]); status.setToolTip(row.get('reason', LABELS[row['status']])) + if row['status'] == 'imported': + self.table.item(n, 0).setCheckState(Qt.CheckState.Unchecked) + self.table.item(n, 0).setFlags(self.table.item(n, 0).flags() & ~Qt.ItemFlag.ItemIsUserCheckable) + self.summary.setText(f'已处理 {processed}/{total} 对;单项失败后继续,已导入项予以保留。') + + def _imported(self, result): + self._phase = None + self.changed.emit() + if self._closed: return + imported = sum(r['status']=='imported' for r in result['rows']) + failed = sum(r['status']=='failed' for r in result['rows']) + state = '已取消,未处理项可继续导入' if result['cancelled'] else '本批导入完成' + self.summary.setText(f'{state}:已导入 {imported} 对,失败 {failed} 对;尚未开始校验。') + self._gates() + + def _failed(self, error): + phase, self._phase = self._phase, None + self.changed.emit() + if self._closed: return + if getattr(error, 'code', None) in ('discovery_cancelled', 'operation_cancelled'): + self.summary.setText('已取消读取,请重新读取配对。') + else: + prefix = '导入中断,已导入项保留:' if phase=='import' else '读取失败:' + self.summary.setText(prefix+str(error)) + self._gates() + + def cancel_operation(self): + self._stop.set() + if self.busy and not self._closed: + self.summary.setText('正在取消,已导入项保留…'); self._gates() + + def reject(self): + self._closed = True; self.cancel_operation() + super().reject() + + def closeEvent(self, event): + self._closed = True; self.cancel_operation() + super().closeEvent(event) 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..ea55a1e --- /dev/null +++ b/src/dx_productivity/trial_task_center/ui/verification_controller.py @@ -0,0 +1,42 @@ +"""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,failed=None): + if self.closed:return + worker=ServiceWorker(action);self.workers[worker.signals]=(worker,received,failed) + 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(object) + def _failed(self,error): + entry=self.workers.get(self.sender()) + if entry and not self.closed: + (entry[2] or self.failed.emit)(error) + + @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..3284208 --- /dev/null +++ b/src/dx_productivity/trial_task_center/ui/verification_inspector.py @@ -0,0 +1,149 @@ +"""Deterministic before/after netlist drawing and matching facts.""" +import json +from PySide6.QtCore import QRectF,Qt,Signal +from PySide6.QtCore import QSignalBlocker +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 PIN_FACT_COLORS,pin_fact,verify_evidence + +ATTEMPTS={'queued':'排队中','running':'执行中','publishing':'保存结果中','stopping':'安全收尾中', + 'succeeded':'执行完成','failed':'执行失败','cancelled':'已停止','interrupted':'已中断'} + + +def _choices(combo,rows,selected): + current=[(combo.itemText(n),combo.itemData(n)) for n in range(combo.count())] + with QSignalBlocker(combo): + if current!=rows: + combo.clear() + for label,value in rows:combo.addItem(label,value) + combo.setCurrentIndex(combo.findData(selected)) + + +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.facts=[];self.setMinimumSize(320,220) + + def set_pins(self,pins,facts): + self.pins=pins;self.facts=facts;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] + label,state=self.facts[n] + color=QColor(PIN_FACT_COLORS[state]) + name=pin['logical_name'] if pin else ('不存在' if label.startswith('器件') else '未覆盖') + change=f' · {label}' if state!='equal' else '' + painter.setPen(color);painter.drawText(QRectF(x+12,y,w-46,24),Qt.AlignmentFlag.AlignLeft, + f"脚 {row['endpoint'][2]} {name}{change}") + 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) + select_attempt=Signal(str) + 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.attempts=QComboBox();layout.addWidget(self.attempts) + 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,6);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())) + self.attempts.activated.connect(lambda _:self.select_attempt.emit(self.attempts.currentData()) if self.attempts.currentData() else None) + + def set_record(self,record): + versions=record.get('versions',sorted({record['current_version'],*(h['input_version'] for h in record['history'])},reverse=True)) + _choices(self.versions,[(f'输入 v{v}',v) for v in versions],record['input_version']) + attempts=[(f"第 {e['generation']} 次校验 · {ATTEMPTS.get(e['state'],'未完成')}",e['attempt_id']) + for e in record['history'] if e['input_version']==record['input_version']] + _choices(self.attempts,attempts,record.get('attempt_id')) + 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 + evidence=result.get('evidence') + if (evidence or {}).get('digest')!=(self.evidence or {}).get('digest'):self.set_evidence(evidence) + self.heading.setText(record['display_name']+' · '+{'CONSISTENT':'一致','WARNING':'需关注','DIFFERENT':'异常','INCOMPLETE':'无法完整校验'}.get(result.get('verdict'),'待校验')) + details=json.dumps({'范围':result.get('scope',record['scope']),'检查':result.get('checks',[]), + '问题':result.get('issues',[]),'执行原因':result.get('reason') or record.get('reason') or record.get('unavailable_reason'), + '输入摘要':record['payload']['payload_digest'],'尝试':record.get('attempt_id')},ensure_ascii=False,indent=2) + if self.facts.toPlainText()!=details:self.facts.setPlainText(details) + + def clear(self): + self.heading.setText('选择工程查看证据');self.facts.clear();self.versions.clear();self.attempts.clear();self.set_evidence(None) + + def set_evidence(self,evidence): + if evidence:verify_evidence(evidence) + previous=self.components.currentData() + 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) + def priority(issue): + related=sum(i.get('refdes')==issue.get('refdes') and i.get('instance_path')==issue.get('instance_path') for i in evidence['issues']) + return (0 if issue['state']=='error' else 1,-related,issue.get('refdes','')) + for issue in sorted(evidence['issues'],key=priority):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() + old=next((n for n in range(self.components.count()) if self.components.itemData(n)==previous),-1) + if old>=0:self.components.setCurrentIndex(old) + elif self.issues.count()>1:self.issues.setCurrentIndex(1);self._issue() + + def _issue(self): + issue=self.issues.currentData() + if issue: + key=(issue.get('instance_path'),issue.get('refdes')) + index=next((n for n in range(self.components.count()) if tuple(self.components.itemData(n))==key),-1) + if index>=0:self.components.setCurrentIndex(index) + + def _component(self): + key=self.components.currentData() + evidence=self.evidence or {} + pins=[p for p in evidence.get('pins',[]) if tuple(p['endpoint'][:2])==key] + issues={issue['issue_id']:issue for issue in evidence.get('issues',())} + facts=[pin_fact(pin,issues) for pin in pins] + self.diagram.set_pins(pins,facts);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)) + label,state=facts[n] + cell=QTableWidgetItem(label) + cell.setForeground(QColor(PIN_FACT_COLORS[state])) + self.pin_table.setItem(n,5,cell) + 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..ef336bd --- /dev/null +++ b/src/dx_productivity/trial_task_center/ui/verification_workspace.py @@ -0,0 +1,280 @@ +"""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,QItemSelectionModel +from PySide6.QtGui import QColor +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.title.setStyleSheet('font-size:20px;font-weight:600;color:#34445b') + self._scroll_to_selection=False;self._view_version=None;self._view_attempt=None;self._selected_attempt=None + self._page_cursor=None + self._task_list_cursor=None + self._next_tasks_cursor=None + self._previous_tasks_cursors=[] + self.new_button=QPushButton('新建校验',objectName='verificationNew');self.import_button=QPushButton('添加工程对') + self.batch_button=QPushButton('批量添加',objectName='verificationBatchImport');self._batch_dialog=None + head.addWidget(self.import_button);head.addWidget(self.batch_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) + task_paging=QHBoxLayout() + self.previous_tasks_button=QPushButton('上一页') + self.next_tasks_button=QPushButton('下一页') + self.previous_tasks_button.setAccessibleName('校验任务上一页') + self.next_tasks_button.setAccessibleName('校验任务下一页') + task_paging.addWidget(self.previous_tasks_button) + task_paging.addWidget(self.next_tasks_button) + ll.addLayout(task_paging) + 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.batch_button.clicked.connect(self._batch_import) + self.tasks.currentItemChanged.connect(self._task_selected);self.table.itemSelectionChanged.connect(self._item_selected) + self.previous_tasks_button.clicked.connect(lambda:self._turn_tasks_page(False)) + self.next_tasks_button.clicked.connect(lambda:self._turn_tasks_page(True)) + self.state_filter.currentIndexChanged.connect(self._filters_changed);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.inspector.select_attempt.connect(self._attempt) + 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._poll) + self._debounce=QTimer(self);self._debounce.setSingleShot(True);self._debounce.setInterval(250);self._debounce.timeout.connect(self._filters_changed) + 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=any(r['item_id']==self.controller.item_id for r in self._rows) + self.import_button.setEnabled(has);self.start_button.setEnabled(has);self.selected_button.setEnabled(has and bool(self.table.selectionModel().selectedRows())) + self.batch_button.setEnabled(has) + self.rerun_button.setEnabled(item);self.export_button.setEnabled(has) + self.stop_button.setEnabled(bool(self._run_id)) + can_page=not self.controller.tasks_query.current_busy + self.previous_tasks_button.setEnabled(can_page and bool(self._previous_tasks_cursors)) + self.next_tasks_button.setEnabled(can_page and self._next_tasks_cursor is not None) + self.busy_changed.emit() + + def set_active(self,active): + self._active=active + if active: + self._timer.start();self.controller.command(self.service.initialize,lambda _:self.refresh()) + else:self._timer.stop() + + def refresh(self): + if self._closed:return + self._refresh_tasks() + if self.controller.task_id:self.refresh_task() + self._gates() + + def _refresh_tasks(self): + cursor=self._task_list_cursor + self.controller.tasks_query.request( + lambda control:self.service.list_tasks(cursor=cursor,read_control=control), + self._tasks_received,self._tasks_failed,cancellable=True) + + def _turn_tasks_page(self,forward): + if forward and self._next_tasks_cursor is not None: + self._previous_tasks_cursors.append(self._task_list_cursor) + self._task_list_cursor=self._next_tasks_cursor + elif not forward and self._previous_tasks_cursors: + self._task_list_cursor=self._previous_tasks_cursors.pop() + else: + return + self._refresh_tasks() + self._gates() + + def _tasks_failed(self,error): + if self._task_list_cursor is not None and getattr(error,'code',None)=='verification_cursor': + self._task_list_cursor=None + self._previous_tasks_cursors.clear() + self._refresh_tasks() + else: + self._error(error) + + def _poll(self): + # Let a slow current read finish; periodic ticks must not keep cancelling it. + queries=(self.controller.tasks_query,self.controller.task_query,self.controller.item_query) + if not self._debounce.isActive() and not any(q.current_busy for q in queries):self.refresh() + + def _tasks_received(self,result): + self._next_tasks_cursor=result['cursor'] + 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) + item.setToolTip(row['name']) + 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._run_id=None;self.notice.clear() + self._scroll_to_selection=True;self._view_version=None;self._view_attempt=None;self._selected_attempt=None + self._rows=[];self._page_cursor=None + with QSignalBlocker(self.table):self.table.setRowCount(0) + self.controller.item_query.invalidate();self.inspector.clear();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._page_cursor=None;self._cursor=None;self._debounce.start() + + def _filters_changed(self,*_): + self._page_cursor=None;self._cursor=None;self.refresh_task() + + def refresh_task(self,*_,append=False): + task=self.controller.task_id + if not task or self._closed:return + cursor=self._cursor if append else self._page_cursor + state,query=self.state_filter.currentData(),self.search.text() + self.controller.task_query.request(lambda control:self.service.read_task(task,state=state, + query=query,cursor=cursor,read_control=control),lambda result:self._task_received(result,cursor), + lambda error:self._task_failed(error,cursor),cancellable=True) + + def _task_failed(self,error,cursor): + if getattr(error,'code',None)=='verification_cursor' and cursor is not None: + self._page_cursor=None;self._cursor=None;self.refresh_task() + else:self._error(error) + + def _task_received(self,result,cursor): + self._run_id=(result.get('run') or {}).get('run_id') + selected_ids={self._rows[i.row()]['item_id'] for i in self.table.selectionModel().selectedRows() if i.row()=0: + self.table.scrollToItem(self.table.item(self.table.currentRow(),0));self._scroll_to_selection=False + 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._view_version,self._view_attempt) + self._gates() + + def _item_selected(self): + row=self.table.currentRow() + if 0<=row1 or len(b)>1 else + 'missing_before' if not a else 'missing_after' if not b else 'ready') + rows.append({'relative_path': (a or b)[0][0], + 'before': a[0][1] if len(a)==1 else None, + 'after': b[0][1] if len(b)==1 else None, 'status': status}) + return rows + + +def import_pairs(service, task_id, pairs, *, request_id, stop_event, on_progress=None, display_names=None): + pairs = tuple((str(a), str(b)) for a, b in pairs) + names = tuple(display_names) if display_names is not None else (None,) * len(pairs) + if len(names) != len(pairs) or any(n is not None and (not isinstance(n, str) or not n.strip()) for n in names): + fail('工程名称必须与工程对一一对应。') + body = [task_id, pairs, names] + result = {'rows': [], 'processed': 0, 'total': len(pairs), 'cancelled': False} + # Successful item receipts survive cancellation; replay never captures them twice. + with service._intake_lock: + service.repo.task(task_id) + with service.repo.store.transaction(): + old = service.repo._request('import-batch', request_id, body) + if old is not None: + return old + if service.repo._request('import-batch-input', request_id, body) is None: + service.repo._remember('import-batch-input', request_id, body, {'bound': True}) + for index, (before, after) in enumerate(pairs): + if stop_event.is_set(): + result['cancelled'] = True + break + row = {'index': index, 'before': before, 'after': after} + try: + receipt = service.import_pair(task_id, before, after, + request_id='batch-row:'+digest([request_id, index, before, after]), stop_event=stop_event, + display_name=names[index]) + if receipt['accepted'] or receipt['duplicates']: + row.update(status='imported', receipt=receipt) + else: + reason = ';'.join(r['reason'] for r in receipt['rejected']) or '工程未被任务接收。' + if names[index] is not None and len(names[index])>256: + reason = '相对路径超过256字符,请缩短目录层级或使用“添加工程对”。' + row.update(status='failed', reason=reason, receipt=receipt) + except TaskCenterError as error: + if error.code == 'operation_cancelled': + result['cancelled'] = True + break + row.update(status='failed', reason=str(error)) + except OSError as error: + # Storage failures affect the whole batch; source-file failures affect one pair. + destination = Path(error.filename).resolve() if error.filename else None + if error.errno in (errno.ENOSPC, errno.EDQUOT, errno.EIO) or ( + destination is not None and destination.is_relative_to(service.data_root)): + raise + row.update(status='failed', reason=str(error)) + except ValueError as error: + row.update(status='failed', reason=str(error)) + result['rows'].append(row) + result['processed'] += 1 + if on_progress: + on_progress(row, result['processed'], result['total']) + if not result['cancelled']: + with service.repo.store.transaction(): + service.repo._remember('import-batch', request_id, body, result) + return result 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..1767f4a --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/contracts.py @@ -0,0 +1,114 @@ +"""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','handoff_saved_items'} + 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('输入版本必须为正整数。') + if 'handoff_saved_items' in result: + count=result['handoff_saved_items'] + if type(count) is not int or count<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 = {} + partial = set() + 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 + if row.get('coverage')=='partial': partial.add(key) + requested = tuple(dict.fromkeys((*required_checks,*optional_checks))) + unknown = [key for key in requested if key in partial or states.get(key, 'unknown') in {'unknown','not_requested'}] + if any(state=='error' for state in states.values()): + verdict = 'DIFFERENT' + elif any(key in unknown 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/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..09172a7 --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/control.py @@ -0,0 +1,171 @@ +"""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 +from .ownership import owner_path,write_owner,read_owner,RunStop + + +class VerificationControl: + def __init__(self,service): + self.service=service;self.repo=service.repo;self.lock=RLock();self.events={};self.thread=None;self.closing=False + self.last_error=None + self.owner_id=uuid4().hex;self._owned_runs=set() + + @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('校验执行器已暂停:'+self.last_error if self.last_error else '校验执行器正在安全关闭。') + 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'])} + members={(row['item_id'],row['input_version']) for row in result['members']} + if selection is not None and not all(tuple(value) in members for value in selection): + fail('当前校验正在运行,未包含所选工程或版本。请等本次运行结束后再启动。','verification_run_active') + 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())) + write_owner(self.service,'runs',run_id,self.owner_id) + result={'run_id':run_id,'members':members} + self.repo._remember('start',request_id,body,result) + owner=read_owner(self.service,'runs',result['run_id']) + if owner.get('owner_id')==self.owner_id and result['members']: + with self.lock:self._owned_runs.add(result['run_id']) + self.wake() + return result + + def wake(self): + with self.lock: + if self._owned_runs and 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='queued' THEN 'stopped' WHEN state='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 _next_run(self): + with self.lock:owned=tuple(self._owned_runs) + if not owned:return None + placeholders=','.join('?' for _ in owned) + return self.repo.connection.execute(f"SELECT * FROM verification_runs WHERE state='queued' AND run_id IN ({placeholders}) ORDER BY created LIMIT 1",owned).fetchone() + + def _dispatch(self): + from .runner import run_attempt + try: + while not self.closing: + with self.repo.store.transaction(): + run=self._next_run() + 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()) + stop=RunStop(self.service,run['run_id'],event) + if run['stop_requested']:event.set() + blocked=False + for member in json.loads(run['members_json']): + result={} + if stop.is_set() or self.closing:break + while not stop.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 stop.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']) + with self.lock:self._owned_runs.discard(run['run_id']) + except Exception as error: + self.closing=True;self.last_error=str(error) + from ..batch_resources import write_record + try:write_record(self.service.data_root/'verification/engine-paused.json',{ + 'reason':str(error),'error':type(error).__name__,'replayed':False}) + except OSError:pass + 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._next_run() + if pending:self.wake() + + def recover(self): + if self.busy:return {'interrupted':0,'blocked':0,'published':0} + result={'interrupted':0,'blocked':0,'published':0,'live_owners':0} + with self.repo.store.transaction(): + active_runs=self.repo.connection.execute("SELECT run_id FROM verification_runs WHERE state IN ('queued','running','stopping')").fetchall() + protected=set() + for run in active_runs: + owner=read_owner(self.service,'runs',run[0]) + if owner['state']=='live' and owner.get('owner_id')!=self.owner_id:protected.add(run[0]) + 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['run_id'] in protected:continue + owner=read_owner(self.service,'attempts',identity,row['owner_id']) + if owner['state']=='live' and owner.get('owner_id')!=self.owner_id: + if row['run_id']:protected.add(row['run_id']) + continue + 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 + for run in active_runs: + if run[0] not in protected:self.repo.connection.execute("UPDATE verification_runs SET state='interrupted' WHERE run_id=?",(run[0],)) + result['live_owners']=len(protected) + return result + + def begin_shutdown(self): + if self.closing:return + self.closing=True + with self.lock:runs=tuple(self._owned_runs) + 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/evidence.py b/src/dx_productivity/trial_task_center/verification/evidence.py new file mode 100644 index 0000000..b483137 --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/evidence.py @@ -0,0 +1,67 @@ +"""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 pin_fact(pin, issues_by_id): + """Interpret stored issues without changing the historical evidence digest.""" + checks={issue['check_id'] for identity in pin['issue_ids'] + if (issue:=issues_by_id.get(identity)) and issue['state']=='error'} + labels=[] + if 'components' in checks: + labels.append('器件新增' if pin['before'] is None else '器件删除') + if 'physical_pins' in checks: + labels.append('物理脚变化') + if 'connections' in checks: + labels.append('连接变化') + if 'net_names' in checks: + labels.append('网名变化') + if pin['text_changed']: + labels.append('引脚名称变化') + if labels: + return '、'.join(labels),'error' if checks else 'warning' + if pin['before'] is None or pin['after'] is None: + return '无法确认','unknown' + return '未发现变化','equal' + + +PIN_FACT_COLORS={'error':'#b83d4a','warning':'#9c6b1e','unknown':'#61758e','equal':'#39817d'} + + +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/intake.py b/src/dx_productivity/trial_task_center/verification/intake.py new file mode 100644 index 0000000..be396e7 --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/intake.py @@ -0,0 +1,98 @@ +"""Managed immutable inputs; native tools never receive arbitrary live paths.""" +import json +import logging +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 ..path_access import internal_path +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 discard(self, identity): + """Remove a directory allocated by this operation before publication.""" + directory=internal_path(self.directory(identity)) + try: + shutil.rmtree(directory) + except FileNotFoundError: + pass + except OSError: + logging.getLogger(__name__).warning('Cannot remove unpublished verification artifact %s',identity,exc_info=True) + + def capture(self, project, *, stop_event, identity=None): + check_cancelled(stop_event) + identity = identity or 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, *, identity=None): + root = Path(capture['root']).resolve() + if not root.is_relative_to(self.data_root): fail('交接副本不属于当前任务库。') + native_netlist._check_capture(capture) + identity = identity or 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/ownership.py b/src/dx_productivity/trial_task_center/verification/ownership.py new file mode 100644 index 0000000..1ca731d --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/ownership.py @@ -0,0 +1,56 @@ +"""Process creation identities for recovery; never terminate a recorded PID.""" +import json +import os +from pathlib import Path +import re +import time +from types import SimpleNamespace +from ..batch_resources import process_identity,_process_gone,write_record +from .contracts import fail + + +def owner_path(service,kind,identity): + if kind not in {'runs','attempts'} or re.fullmatch('[0-9a-f]{32}',identity or '') is None:fail('执行归属标识无效。') + root=(service.data_root/'verification').resolve() + path=root/kind/identity/'owner.json' + if not path.resolve().is_relative_to(root):fail('执行归属目录越界。') + return path + + +def write_owner(service,kind,identity,owner_id): + process={'pid':os.getpid(),'creation_time':None} + if os.name=='nt': + import win32api + process=process_identity(SimpleNamespace(pid=os.getpid(),handle=win32api.GetCurrentProcess())) + write_record(owner_path(service,kind,identity),{'version':1,'identity':identity,'owner_id':owner_id, + 'process':process,'scope':'OwnedCliScope','kill_on_owner_exit':True}) + + +def read_owner(service,kind,identity,expected_owner=None): + try: + value=json.loads(owner_path(service,kind,identity).read_text(encoding='utf-8')) + if (value.get('version')!=1 or value.get('identity')!=identity or value.get('scope')!='OwnedCliScope' + or value.get('kill_on_owner_exit') is not True or not isinstance(value.get('owner_id'),str) + or (expected_owner and value['owner_id']!=expected_owner)):raise ValueError('归属证明不符') + identity_record=value['process'] + if type(identity_record.get('pid')) is not int or identity_record['pid']<=0:raise ValueError('进程证明无效') + if os.name!='nt' or not identity_record.get('creation_time'):state='unknown' + else:state='gone' if _process_gone(identity_record) else 'live' + return dict(value,state=state) + except Exception:return {'state':'unknown'} # An inaccessible process is never proof of release. + + +class RunStop: + """An Event-compatible token that observes another window's durable stop.""" + def __init__(self,service,run_id,event):self.service=service;self.run_id=run_id;self.event=event + def is_set(self): + if self.event.is_set():return True + with self.service.repo.store._lock: + row=self.service.repo.connection.execute('SELECT stop_requested FROM verification_runs WHERE run_id=?',(self.run_id,)).fetchone() + return row is None or bool(row[0]) + def wait(self,timeout=None): + deadline=None if timeout is None else time.monotonic()+timeout + while not self.is_set(): + if deadline is not None and time.monotonic()>=deadline:return False + self.event.wait(.05 if deadline is None else min(.05,max(0,deadline-time.monotonic()))) + return True 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..cd3f2de --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/pin_metadata.py @@ -0,0 +1,59 @@ +"""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):dict({phase:{name:row[name]['value'] for name in ('pin_value','electrical_type')} + for phase,row in (('before',left[key]),('after',right[key]))} + ,endpoint=list(key)) + for key in left.keys()&right.keys()}} 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..d396a63 --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/queries.py @@ -0,0 +1,138 @@ +"""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;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) + 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() + result=[] + for row in rows: + checkpoint(control);row=project(row) + result.append(row) + return result + + def validate_rows(self,rows,control=None): + for row in rows: + checkpoint(control) + if self.validator and row['attempt_state']=='succeeded':self._validate(row,self.repo.attempt(row['attempt_id'])) + return 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(): + tasks.append(row) + binding=digest([query,[r['task_id'] for r in tasks]]) + page,next_cursor=paginate(tasks,cursor,limit,binding,50) + for row in page: + row['_rows']=self._rows(row['task_id'],read_control) + for row in page:row['summary']=summarize_items(self.validate_rows(row.pop('_rows'),read_control)) + 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) + run=self.repo.connection.execute("SELECT run_id,state,stop_requested FROM verification_runs WHERE task_id=? AND state IN ('queued','running','stopping') ORDER BY created LIMIT 1",(task_id,)).fetchone() + self.validate_rows(rows,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),run=dict(run) if run else None) + + def read_item(self,item_id,*,version=None,attempt_id=None,read_control=None): + row=self.snapshot_item(item_id,version=version,attempt_id=attempt_id,read_control=read_control) + return self._validate(row,row['attempt']) + + def snapshot_item(self,item_id,*,version=None,attempt_id=None,read_control=None): + with self.repo.store.transaction(): + checkpoint(read_control) + item=self.repo.item(item_id) + attempt=self.repo.attempt(attempt_id) if attempt_id else None + if attempt: + if attempt['item_id']!=item_id or (version is not None and attempt['input_version']!=version):fail('历史尝试不属于该工程版本。') + version=attempt['input_version'] + version=version or item['current_version'] + revision=self.repo.revision(item_id,version);attempt=attempt or 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,))] + versions=[r[0] for r in self.repo.connection.execute('SELECT input_version FROM verification_input_revisions WHERE item_id=? ORDER BY input_version DESC',(item_id,))] + return dict(project(row),payload=revision['payload'],attempt=attempt,history=history,versions=versions) + + 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/report.py b/src/dx_productivity/trial_task_center/verification/report.py new file mode 100644 index 0000000..9c8f9a0 --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/report.py @@ -0,0 +1,136 @@ +"""HTML and JSON views of the exact immutable evidence shown in the workspace.""" +from html import escape +import json +from pathlib import Path +from uuid import uuid4 +from ..native_netlist import _hash +from ..batch_resources import write_record +from ..path_access import internal_path +from .contracts import fail,digest +from .evidence import PIN_FACT_COLORS,pin_fact,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,issues): + 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];fact,state=pin_fact(pin,issues);color=PIN_FACT_COLORS[state] + out.append(f'{text(fact)}') + name=row['logical_name'] if row else ('不存在' if fact.startswith('器件') else '未知') + out.append(f'脚 {text(pin["endpoint"][2])} · {text(name)}') + 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 name) + out.append(f'{text(label)}') + return ''.join(out)+'' + + +def item_html(result): + validate_result(result) + evidence=result.get('evidence') or {};pins=evidence.get('pins',[]) + issues={issue['issue_id']:issue for issue in evidence.get('issues',())} + verdict=result.get('verdict','未完成') + label={'CONSISTENT':'一致','WARNING':'需关注','DIFFERENT':'异常','INCOMPLETE':'无法完整校验'}.get(verdict,'未完成') + out=[f'

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

',f'

{label} · {text(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,issues)) + out.append('') + for pin in subset: + def description(row): + if row is None:return '不存在/未覆盖' + nets=';'.join(n['name']+' → '+', '.join(e[1]+'.'+e[2] for e in n['endpoints'] if e!=pin['endpoint']) for n in row['nets']) + return '名称:'+row['logical_name']+'\n'+(nets or '明确未连接') + label,_=pin_fact(pin,issues) + out.append(f'') + out.append('
物理脚修改前修改后事实
{text(pin["endpoint"][2])}
{text(description(pin["before"]))}
{text(description(pin["after"]))}
{text(label)}
') + out.append('

判断依据

    ') + for issue in result.get('issues',[]): + out.append(f'
  • {text(issue.get("refdes","工程"))} {text(issue.get("pin_number",""))} · {text(issue["reason"])}
  • ') + out.append('
') + if result.get('reason'):out.append('

执行说明:'+text(result['reason'])+'

') + out.append('
检查范围、版本与完整事实
'+text({key:result.get(key) for key in ('attempt_state','resource_state','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) + target=internal_path(destination) + if target.exists():fail('报告文件已存在,请换一个名称。') + fields={'item-id':result_ref.get('item_id'),'attempt-id':result_ref.get('attempt_id'), + 'input-version':result_ref.get('input_version'),'generation':result_ref.get('generation'), + 'input-digest':result_ref.get('input_digest'),'evidence-digest':(result_ref.get('evidence') or {}).get('digest')} + binding=' '.join(f'data-{key}="{text(value)}"' for key,value in fields.items()) + html='工程校验报告
'+item_html(result_ref)+'
' + target.parent.mkdir(parents=True,exist_ok=True) + temporary=target.with_name('.'+uuid4().hex+'.tmp') + try: + temporary.write_text(html,encoding='utf-8') + # On Windows rename does not overwrite an existing destination. + if target.exists():fail('报告文件已存在。') + temporary.rename(target) + 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 internal_path(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.queries.snapshot_item(row['item_id']) for row in rows] + snapshot=dict(task,items=records) + for row in records: + service.queries._validate(row,row['attempt']) + if row.get('evidence_error'):fail('证据不可用,不能导出为有效报告:'+row['evidence_error']) + root=Path(destination).resolve();internal_path(root).mkdir(parents=True,exist_ok=True) + output=root/f'verification-{task_id[:12]}-v{task["view_revision"]}-{digest(request_id)[:8]}' + target=internal_path(output) + if target.exists():fail('报告目录已存在。') + staging=internal_path(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(target) + 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/rules.py b/src/dx_productivity/trial_task_center/verification/rules.py new file mode 100644 index 0000000..525f223 --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/rules.py @@ -0,0 +1,174 @@ +"""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') and e['graph'].get('nets') + 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','器件身份或覆盖无法唯一证明') + if complete: + for key,(lid,rid) in matched['matches'].items(): + lnums=[p.get('number') for p in left['components'][lid].get('pins',{}).values()] + rnums=[p.get('number') for p in right['components'][rid].get('pins',{}).values()] + if lnums and rnums and all(lnums+rnums) and Counter(lnums)!=Counter(rnums): + issue('physical_pins','error','物理脚号或占用次数变化',key=key,left=lnums,right=rnums) + 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: + if states['physical_pins']!='error':states['physical_pins']='equal' + 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: + bound=fields.get('endpoint') + issue('pin_text' if key=='pin_value' else 'pin_semantics','warning','引脚字段变化,需人工确认', + key=tuple(bound[:2]) if bound else None,pin=bound[2] if bound else None,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)] + # This dimension covers names AND pin-level Value. Native text has not proven Value. + for check in checks: + if check['check_id']=='pin_text' and 'pin_text' in requested: + check.update(coverage='partial',unknown_fields=['pin_value']) + if check['check_id']=='pin_semantics' and 'pin_semantics' in requested: + expected={e for e in views[0] if e[:2] in matched['matches']} if views else set() + proven={tuple(fields['endpoint']) for fields in (pin_metadata or {}).get('comparisons',{}).values() + if fields.get('endpoint') and all(fields.get(phase,{}).get('electrical_type') is not None for phase in ('before','after'))} + if not expected or not expected<=proven:check.update(coverage='partial',unknown_fields=['electrical_type']) + 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 new file mode 100644 index 0000000..23b93e2 --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/runner.py @@ -0,0 +1,98 @@ +"""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): + from ..native_cli import _UNCERTAIN_SCOPES + 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 _UNCERTAIN_SCOPES 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) + from .ownership import write_owner,RunStop + with service.repo.store.transaction(): + attempt=service.repo.claim(attempt_id,owner_id=service.control.owner_id) + if attempt:write_owner(service,'attempts',attempt_id,attempt['owner_id']) + if attempt is None:return {'published':False} + if attempt['run_id']:stop_event=RunStop(service,attempt['run_id'],stop_event) + check_cancelled(stop_event) + 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} + 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 + 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' if all(e.get('status')=='success' for e in (left,right)) else 'failed',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']) + 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 + write_record(output/'result-ready.json',{'result_ref':ref}) + check_cancelled(stop_event) + published=service.repo.finish(attempt_id,generation=attempt['generation'],result=result) + if not published and stop_event.is_set(): + service.repo.finish(attempt_id,generation=attempt['generation'],result={ + 'attempt_state':'cancelled','resource_state':'released','verdict':'INCOMPLETE','reason':'用户停止先于结果提交', + 'attempt_id':attempt_id,'input_version':attempt['input_version'],'checks':[],'issues':[]}) + 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':[]} + service.repo.finish(attempt_id,generation=attempt['generation'],result=result) + return {'published':False,'reason':str(error)} + finally: + _native_lock.release() 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..5432e1e --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/service.py @@ -0,0 +1,335 @@ +"""One interface for standalone verification and successful-result handoff.""" +from contextlib import ExitStack +from hashlib import sha256 +import json +from pathlib import Path +from threading import RLock +from uuid import uuid4 + +from ..native_netlist import _check_capture +from ..path_access import canonical_path, internal_path +from ..errors import TaskCenterError +from ..operation_control import check_cancelled +from .contracts import default_plan, digest, fail, identifier, validate_input +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() + 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 + + 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) + 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') + if payload['expectation_ref']:self.artifacts.read(payload['expectation_ref'],'expectations') + + 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) + + def preview_pairs(self, before_root, after_root, *, stop_event): + from .batch_import import preview_pairs + return preview_pairs(before_root,after_root,excluded_roots=(self.data_root,),stop_event=stop_event) + + def import_pairs(self, task_id, pairs, *, request_id, stop_event, on_progress=None, display_names=None): + from .batch_import import import_pairs + return import_pairs(self,task_id,pairs,request_id=request_id,stop_event=stop_event,on_progress=on_progress,display_names=display_names) + + 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=self._validated_inputs(inputs) + 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 _validated_inputs(self, inputs): + # Snapshot hashing can be slow; never run it inside a store transaction. + 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) + return normalized + + def import_pair(self, task_id, before, after, *, request_id, stop_event, display_name=None): + body=[task_id,str(before),str(after)] + if display_name is not None:body.append(display_name) + 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}') + project_key=digest([str(before),str(after)]) + name=after.stem if display_name is None else display_name + try: + identifier(name or project_key) + except TaskCenterError as error: + result={'accepted':[],'duplicates':[],'stale_ignored':[], + 'rejected':[{'index':0,'code':error.code,'reason':error.message}]} + with self.repo.store.transaction(): + old=self.repo._request('import',request_id,body) + return old if old is not None else self.repo._remember('import',request_id,body,result) + with ExitStack() as unpublished: + refs={} + for phase,project in (('before',before),('after',after)): + identity=uuid4().hex + unpublished.callback(self.artifacts.discard,identity) + refs[phase]=self.artifacts.capture(project,stop_event=stop_event,identity=identity) + row={'item_key':uuid4().hex,'project_key':project_key,'display_name':name, + 'input_version':1,'before_ref':refs['before'],'after_ref':refs['after'], + 'expectation_ref':None,'check_plan':default_plan()} + normalized=self._validated_inputs((row,)) + with self.repo.store.transaction(): + old=self.repo._request('import',request_id,body) + if old is not None:return old + check_cancelled(stop_event) + result=self.repo.publish(task_id,tuple(normalized),submission_id='import:'+request_id) + self.repo._remember('import',request_id,body,result) + if result['accepted']: + unpublished.pop_all() + return result + + def receive_successful_results(self, result_ref, *, submission_id): + with self._intake_lock: + with self.repo.store._lock: + completed=self.repo._request('handoff-complete',submission_id,result_ref) + if completed is not None:return completed + old=self.repo._request('handoff',submission_id,result_ref) + if old is not None and not old['rejected']: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']}, + 'task_name':task.get('name',task['task_id'])})) + empty={key:[] for key in ('accepted','duplicates','stale_ignored','rejected')} + if not candidates:return empty + with self.repo.store.transaction(): + if self.repo._request('handoff-receipt',submission_id,result_ref) is None: + self.repo._remember('handoff-receipt',submission_id,result_ref,True) + 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'] + result=dict(empty,task_id=task) + for index,(key,report) in enumerate(candidates): + try: + delivery_key=digest([run_key,key,report]) + status,reference=self._deliver_project(task,str(key),report,delivery_key) + except (ValueError,OSError,KeyError,TypeError) as error: + result['rejected'].append({'index':index,'code':getattr(error,'code','verification_evidence'), + 'reason':str(error)}) + else: + result[status].append(reference) + if result['rejected']: + return result + with self.repo.store.transaction(): + completed=self.repo._request('handoff-complete',submission_id,result_ref) + return completed if completed is not None else self.repo._remember( + 'handoff-complete',submission_id,result_ref,result) + + def _deliver_project(self, task, key, report, delivery_key): + for _ in range(3): + with self.repo.store._lock: + known=self.repo._request('handoff-input',delivery_key,report) + if known is not None: + return 'duplicates',known + current=self.repo.current_input(task,key) + legacy=self.repo._request('handoff-row',delivery_key,report) + if current and legacy: + first=self.repo.revision(current['item_id'],1) + if first['payload_digest']==validate_input(legacy)['payload_digest']: + return 'duplicates',{'item_id':first['item_id'],'input_version':1} + with ExitStack() as unpublished: + row=self._prepare_handoff_input(key,report,current,unpublished) + with self.repo.store.transaction(): + known=self.repo._request('handoff-input',delivery_key,report) + if known is not None: + return 'duplicates',known + if self.repo.current_input(task,key)!=current: + continue + if row is None: + reference={field:current[field] for field in ('item_id','input_version')} + return 'stale_ignored',reference + if current and row['input_version']==current['input_version']: + status='duplicates' + reference={field:current[field] for field in ('item_id','input_version')} + else: + if current and row['project_key']!=current['payload']['project_key']: + self.repo.connection.execute( + 'UPDATE verification_items SET project_key=? WHERE item_id=? AND before_id IS NULL', + (row['project_key'],current['item_id'])) + published=self.repo.publish(task,(row,),submission_id='handoff-input:'+delivery_key) + if published['rejected']: + rejection=published['rejected'][0] + fail(rejection['reason'],rejection['code']) + status='accepted' + reference=published['accepted'][0] + self.repo._remember('handoff-input',delivery_key,report,reference) + if status=='accepted': + unpublished.pop_all() + return status,reference + fail('交接项正在更新,请稍后重试。','verification_conflict') + + def _prepare_handoff_input(self, key, report, current, unpublished): + previous=current['payload'] if current else {} + project=str(report.get('project_path') or previous.get('project_key') or key) + saved_items=report['execution']['saved_items'] + project_changed=bool(current and previous['project_key']!=project) + expected=None + previous_expected=None + if previous.get('expectation_ref'): + previous_expected=self.artifacts.read(previous['expectation_ref'],'expectations') + previous_count=previous.get('handoff_saved_items') or ( + (previous_expected or {}).get('execution',{}).get('saved_items') or 0) + if saved_itemsprevious_count or any(previous.get(field)!=value for field,value in row.items() + if field!='handoff_saved_items'): + version+=1 + row['input_version']=version + return row + + def _handoff_capture(self, evidence): + path=canonical_path(evidence.get('export_path','')) + if not path.is_relative_to(self.data_root) or not internal_path(path).is_file(): + fail('缺少可信前后副本。') + content=internal_path(path).read_bytes() + if sha256(content).hexdigest()!=evidence.get('export_sha256'): + fail('交接导出摘要不符。') + capture=json.loads(content)['capture'] + if not canonical_path(capture['root']).is_relative_to(self.data_root): + fail('交接副本不属于当前任务库。') + _check_capture(capture) + return capture + + 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']) + for rejection in record['rejected']: + result['errors'].append({'record':path.name,'reason':rejection['reason']}) + except (ValueError,OSError,KeyError,TypeError) as error: + result['errors'].append({'record':path.name,'reason':str(error)}) + return result 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..81373ab --- /dev/null +++ b/src/dx_productivity/trial_task_center/verification/store.py @@ -0,0 +1,206 @@ +"""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 UNIQUE INDEX IF NOT EXISTS verification_attempt_generation + ON verification_attempts(item_id,input_version,generation DESC)''', + '''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 current_input(self,task_id,item_key): + with self.store._lock: + item=self.connection.execute( + 'SELECT item_id,current_version FROM verification_items WHERE task_id=? AND item_key=?', + (task_id,item_key)).fetchone() + return self.revision(*item) if item else None + + 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('无效校验终态。') + if attempt['run_id'] and state not in {'cancelled','interrupted'}: + run=self.connection.execute('SELECT stop_requested FROM verification_runs WHERE run_id=?',(attempt['run_id'],)).fetchone() + if run and run[0]:return False + 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/dsh/test_incident_rule_retry.py b/tests/dsh/test_incident_rule_retry.py index b56e3bb..15dcd3d 100644 --- a/tests/dsh/test_incident_rule_retry.py +++ b/tests/dsh/test_incident_rule_retry.py @@ -192,10 +192,11 @@ def test_legacy_rule_retry_cannot_create_a_replacement_before_baseline(rule_run) assert receipt['execution_status'] == 'completed' and receipt['acceptance']['status'] == 'unavailable' -def test_retry_receipt_refresh_preserves_other_task_without_dispatch(tmp_path, monkeypatch): +def test_retry_receipt_refresh_preserves_other_task_without_dispatch(tmp_path, monkeypatch, request): from types import SimpleNamespace as NS - from dx_productivity.dsh.execution_runs import execute_incident_retry + from dx_productivity.dsh.execution_runs import _finish_execution_run, execute_incident_retry from dx_productivity.trial_task_center import netlist_verification, task_queue + from dx_productivity.trial_task_center.verification.service import VerificationService selected, other, run_id = 'a' * 32, 'b' * 32, 'c' * 32 hashes = {selected: 'd' * 64, other: 'e' * 64} monkeypatch.setattr(task_queue, '_plan_hash', lambda child, key: hashes[key]) @@ -206,22 +207,32 @@ def test_retry_receipt_refresh_preserves_other_task_without_dispatch(tmp_path, m def execute(key, **options): dispatch.append(key) return NS(paused=False) - service = NS(for_project_task=lambda key: service, task_context=context, execute_quick_run_queue=execute) + store = TaskStore(tmp_path / 'tasks.db') + request.addfinalizer(store.close) + verification_service = VerificationService(store, tmp_path) + service = NS(for_project_task=lambda key: service, task_context=context, execute_quick_run_queue=execute, + verification=verification_service) class Checks: def __init__(self, *args): self.tasks = {} def __enter__(self): return self def __exit__(self, *args): pass def before_task(self, child, key, *, existing_only): assert existing_only def after_task(self, key, **options): assert key == selected - def finish(self): return {selected: {'status': 'verified', 'verified': True, 'report_path': 'new.json'}} + def finish(self): + return {selected: {'status': 'verified', 'verified': True, 'report_path': 'new.json', + 'execution': {'state': 'completed', 'saved_items': 1}}} monkeypatch.setattr(netlist_verification, 'NetlistVerification', Checks) journal = RunJournal(tmp_path) journal.begin(run_id, [selected, other], hashes) old_other = {'task_id': other, 'state': 'completed', 'message': 'original saved result'} - old_report = {'status': 'verified', 'verified': True, 'report_path': 'original.json'} - journal.finish(run_id, {'status': 'failed', 'entries': [ - {'task_id': selected, 'state': 'failed', 'message': 'safe failure'}, old_other], - 'netlist_verification': {other: old_report}}) + old_report = {'status': 'verified', 'verified': True, 'report_path': 'original.json', + 'execution': {'state': 'completed', 'saved_items': 1}} + initial = task_queue.TaskQueueResult(run_id, ( + task_queue.TaskQueueEntry(selected, 'failed', 'safe failure'), + task_queue.TaskQueueEntry(**old_other)), False, netlist_verification={other: old_report}) + _finish_execution_run(service, tmp_path, [selected, other], Event(), run_id, initial, baseline={}) + verification_task = verification_service.list_tasks()['tasks'][0]['task_id'] + assert verification_service.read_task(verification_task)['summary']['total'] == 1 checkpoint = tmp_path / 'task-queues' / (run_id + '.json') checkpoint.parent.mkdir() checkpoint.write_text(json.dumps({'version': 1, 'phase': 'finished', 'task_ids': [selected, other], @@ -234,6 +245,7 @@ def test_retry_receipt_refresh_preserves_other_task_without_dispatch(tmp_path, m assert next(row for row in receipt['entries'] if row['task_id'] == other) == old_other assert receipt['netlist_verification'][other] == old_report assert json.loads(checkpoint.read_text())['entries'][other] == {'state': 'completed', 'message': 'original saved result'} + assert {row['item_key'] for row in verification_service.read_task(verification_task)['items']} == {selected, other} @pytest.mark.parametrize('scheduled', [False, True]) diff --git a/tests/ui/test_verification_acceptance.py b/tests/ui/test_verification_acceptance.py new file mode 100644 index 0000000..d5fcc58 --- /dev/null +++ b/tests/ui/test_verification_acceptance.py @@ -0,0 +1,22 @@ +from threading import Event + + +def test_mixed_result_inspector_shows_error_and_keeps_new_task_enabled(ui,qtbot): + from pathlib import Path + import sys + sys.path.insert(0,str(Path(__file__).parents[1]/'v1_1')) + from test_independent_verification_rules import export,evaluate + from dx_productivity.trial_task_center.verification.evidence import build_evidence + from test_independent_verification_contracts import payload + import copy + v=ui.service.verification;task=v.create_task('人工复核',request_id='accept')['task_id'] + row=payload();item=v.repo.publish(task,(row,),submission_id='direct')['accepted'][0]['item_id'] + 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.update(resource_state='released',evidence=build_evidence(a['graph'],b['graph'],result['issues'],binding={})) + attempt=v.repo.create_attempt(item,1,request_id='a');v.repo.claim(attempt['attempt_id'],owner_id='controlled') + v.repo.finish(attempt['attempt_id'],generation=1,result=result) + page=ui.window.verification_panel;page.open_task(task,item);ui.window.verification_action.trigger() + qtbot.waitUntil(lambda:'异常' in page.inspector.heading.text()) + assert page.new_button.isEnabled() and page.inspector.pin_table.rowCount()==2 + assert page.inspector.diagram.pins[0]['endpoint'][2]=='1' + assert '已处理 1/1' in page.footer.text() diff --git a/tests/ui/test_verification_batch_import.py b/tests/ui/test_verification_batch_import.py new file mode 100644 index 0000000..b162a29 --- /dev/null +++ b/tests/ui/test_verification_batch_import.py @@ -0,0 +1,100 @@ +from pathlib import Path +import sys +from threading import Event + +from PySide6.QtCore import Qt + +sys.path.insert(0, str(Path(__file__).parents[1]/'v1_1')) +from test_native_cli_netlist import project_fixture + + +def projects(tmp_path): + roots = tmp_path/'before', tmp_path/'after' + for root in roots: + for name in ('A', 'B'): + directory = root/name + directory.mkdir(parents=True) + project_fixture(directory) + directory = roots[0]/'only-before' + directory.mkdir() + project_fixture(directory) + return roots + + +def test_batch_preview_imports_only_checked_pairs_without_running_verification(ui, qtbot, tmp_path): + from dx_productivity.trial_task_center.ui.verification_batch_import import VerificationBatchDialog + page = ui.window.verification_panel + task = page.service.create_task('批量', request_id='batch')['task_id'] + page.open_task(task) + page.batch_button.click() + dialog = page._batch_dialog + assert isinstance(dialog, VerificationBatchDialog) and dialog.isVisible() and not dialog.isModal() + before, after = projects(tmp_path) + dialog.before.setText(str(before)); dialog.after.setText(str(after)) + dialog.scan.click() + qtbot.waitUntil(lambda: not dialog.busy) + assert dialog.table.rowCount() == 3 + assert dialog.table.item(2, 0).checkState() == Qt.CheckState.Unchecked + assert not dialog.table.item(2, 0).flags() & Qt.ItemFlag.ItemIsUserCheckable + dialog.table.item(1, 0).setCheckState(Qt.CheckState.Unchecked) + dialog.import_button.click() + qtbot.waitUntil(lambda: not dialog.busy) + data = page.service.read_task(task) + assert data['summary']['total'] == 1 + assert data['items'][0]['display_name'] == 'A/source/board.prj' + assert data['summary']['waiting'] == 1 + assert page.new_button.isEnabled() and dialog.import_button.isEnabled() is False + assert page.service.repo.connection.execute('SELECT COUNT(*) FROM verification_attempts').fetchone()[0] == 0 + dialog.reject() + + +def test_batch_cancel_keeps_first_pair_and_main_page_can_create_another_task(ui, qtbot, tmp_path, monkeypatch): + from dx_productivity.trial_task_center.ui.verification_batch_import import VerificationBatchDialog + page = ui.window.verification_panel + task = page.service.create_task('批量', request_id='batch')['task_id'] + page.open_task(task) + dialog = VerificationBatchDialog(page.service, page.controller, task, '批量', page) + qtbot.addWidget(dialog) + before, after = projects(tmp_path) + dialog.before.setText(str(before)); dialog.after.setText(str(after)); dialog.scan.click() + qtbot.waitUntil(lambda: not dialog.busy) + entered, release = Event(), Event() + original = page.service.import_pair + def slow(*args, **kwargs): + result = original(*args, **kwargs) + entered.set(); release.wait(5) + return result + monkeypatch.setattr(page.service, 'import_pair', slow) + dialog.import_button.click() + qtbot.waitUntil(entered.is_set) + try: + assert page.new_button.isEnabled() + other = page.service.create_task('另一个任务', request_id='other')['task_id'] + assert other != task + dialog.cancel_button.click() + finally: + release.set() + qtbot.waitUntil(lambda: not dialog.busy) + assert page.service.read_task(task)['summary']['total'] == 1 + dialog.reject() + + +def test_closing_preview_cancels_scan_without_late_table_changes(ui, qtbot, tmp_path, monkeypatch): + from dx_productivity.trial_task_center.ui.verification_batch_import import VerificationBatchDialog + page = ui.window.verification_panel + task = page.service.create_task('关闭读取', request_id='batch')['task_id'] + dialog = VerificationBatchDialog(page.service, page.controller, task, '关闭读取', page) + qtbot.addWidget(dialog) + before, after = projects(tmp_path) + entered, release = Event(), Event() + scan = page.service.preview_pairs + def slow(*args, **kwargs): + entered.set(); release.wait(5) + return scan(*args, **kwargs) + monkeypatch.setattr(page.service, 'preview_pairs', slow) + dialog.before.setText(str(before)); dialog.after.setText(str(after)); dialog.scan.click() + qtbot.waitUntil(entered.is_set) + dialog.reject(); release.set() + qtbot.waitUntil(lambda: not page.controller.workers) + assert not dialog.busy and dialog.table.rowCount() == 0 + assert page.service.read_task(task)['summary']['total'] == 0 diff --git a/tests/ui/test_verification_control.py b/tests/ui/test_verification_control.py new file mode 100644 index 0000000..43df32f --- /dev/null +++ b/tests/ui/test_verification_control.py @@ -0,0 +1,38 @@ +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() + + +def test_shutdown_is_idempotent_after_store_is_released(ui,qtbot): + page=ui.window.verification_panel + page.shutdown() + original=page.service.begin_shutdown + def forbidden():raise AssertionError('closed page must not access released store') + page.service.begin_shutdown=forbidden + try:page.shutdown() + finally:page.service.begin_shutdown=original + + +def test_finished_run_does_not_leave_stop_enabled(ui,qtbot): + page=ui.window.verification_panel + task=page.service.create_task('空任务',request_id='finished')['task_id'] + page.open_task(task) + page._started({'run_id':'already-finished'}) + qtbot.waitUntil(lambda:not page.controller.task_query.busy) + assert not page.stop_button.isEnabled() + + +def test_cancelling_window_close_does_not_close_verification_admission(ui,monkeypatch): + from dx_productivity.trial_task_center.ui.verification_workspace import VerificationWorkspace + ui.settle();window=ui.window + with monkeypatch.context() as patch: + patch.setattr(VerificationWorkspace,'busy',property(lambda self:True)) + patch.setattr(window.plan_panel,'has_unsaved_plans',lambda:True) + window._close_plan_confirmer=lambda:'cancel' + assert not window.close() + assert not window.verification_panel.service.control.closing diff --git a/tests/ui/test_verification_inspector.py b/tests/ui/test_verification_inspector.py new file mode 100644 index 0000000..dfa259d --- /dev/null +++ b/tests/ui/test_verification_inspector.py @@ -0,0 +1,34 @@ +from dx_productivity.trial_task_center.verification.evidence import build_evidence + + +def test_inspector_uses_evidence_pin_table_and_explicit_coverage(qtbot): + from dx_productivity.trial_task_center.ui.verification_inspector import VerificationInspector + from pathlib import Path + import sys + sys.path.insert(0,str(Path(__file__).parents[1]/'v1_1')) + from test_independent_verification_rules import export,evaluate + a=export();result=evaluate(a,a) + evidence=build_evidence(a['graph'],a['graph'],result['issues'],binding={}) + widget=VerificationInspector();qtbot.addWidget(widget) + widget.set_evidence(evidence) + assert widget.pin_table.rowCount()>=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]] + + +def test_same_result_refresh_keeps_the_chosen_issue(qtbot): + from dx_productivity.trial_task_center.ui.verification_inspector import VerificationInspector + from pathlib import Path + import sys,copy + sys.path.insert(0,str(Path(__file__).parents[1]/'v1_1')) + from test_independent_verification_rules import export,evaluate + 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);result['evidence']=build_evidence(a['graph'],b['graph'],result['issues'],binding={}) + record={'current_version':1,'input_version':1,'attempt_id':'attempt','display_name':'board','scope':'未核对换料规则', + 'payload':{'payload_digest':'0'*64},'history':[{'input_version':1,'generation':1,'attempt_id':'attempt','state':'succeeded'}], + 'attempt':{'result':result}} + widget=VerificationInspector();qtbot.addWidget(widget);widget.set_record(record) + widget.issues.setCurrentIndex(1);widget.set_record(record) + assert widget.issues.currentIndex()==1 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/ui/test_verification_workspace.py b/tests/ui/test_verification_workspace.py new file mode 100644 index 0000000..0ecf4fe --- /dev/null +++ b/tests/ui/test_verification_workspace.py @@ -0,0 +1,81 @@ +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 + + +def test_periodic_refresh_does_not_starve_a_slow_read(ui,qtbot,monkeypatch): + from threading import Event + from pathlib import Path + import sys + sys.path.insert(0,str(Path(__file__).parents[1]/'v1_1')) + from test_independent_verification_contracts import payload + page=ui.window.verification_panel;v=page.service + task=v.create_task('慢查询',request_id='slow')['task_id'];row=payload();row['before_ref']=None + v.repo.publish(task,(row,),submission_id='row') + original=v.read_task + def slow(*args,**kwargs):Event().wait(.15);return original(*args,**kwargs) + monkeypatch.setattr(v,'read_task',slow) + page.open_task(task);page._timer.setInterval(20);page._timer.start() + try:qtbot.waitUntil(lambda:page.table.rowCount()==1,timeout=1500) + finally:page._timer.stop() + + +def test_engineering_pages_remain_bounded_and_keep_the_current_page(ui,qtbot): + from pathlib import Path + import sys + sys.path.insert(0,str(Path(__file__).parents[1]/'v1_1')) + from test_independent_verification_contracts import payload + page=ui.window.verification_panel;v=page.service + task=v.create_task('分页',request_id='pages')['task_id'];rows=[] + for n in range(201): + row=payload();row.update(item_key=str(n),display_name=f'Board{n:03}',before_ref=None);rows.append(row) + v.repo.publish(task,rows,submission_id='rows');page.open_task(task) + qtbot.waitUntil(lambda:page.table.rowCount()==100) + page.more_button.click() + qtbot.waitUntil(lambda:not page.controller.task_query.busy) + assert page.table.rowCount()==100 and page.table.item(0,0).text()=='Board100' + page.refresh_task();qtbot.waitUntil(lambda:not page.controller.task_query.busy) + assert page.table.item(0,0).text()=='Board100' + page.search.setText('Board000') + qtbot.waitUntil(lambda:page.table.rowCount()==1) + assert page.table.item(0,0).text()=='Board000' + + +def test_older_verification_task_can_be_opened_after_paging(ui,qtbot): + page=ui.window.verification_panel + tasks=[page.service.create_task(f'任务 {n}',request_id=f'page-{n}')['task_id'] for n in range(51)] + page.open_task(tasks[-1]) + qtbot.waitUntil(lambda:page.tasks.count()==50 and not page.controller.tasks_query.busy) + page.next_tasks_button.click() + qtbot.waitUntil(lambda:page.tasks.count()==1) + assert page.tasks.item(0).data(Qt.ItemDataRole.UserRole)==tasks[0] + page.tasks.setCurrentRow(0) + qtbot.waitUntil(lambda:page.controller.task_id==tasks[0] and not page.controller.tasks_query.busy) + page.refresh() + qtbot.waitUntil(lambda:not page.controller.tasks_query.busy) + assert page.tasks.currentItem().data(Qt.ItemDataRole.UserRole)==tasks[0] + page.previous_tasks_button.click() + qtbot.waitUntil(lambda:page.tasks.count()==50) diff --git a/tests/v1_1/test_independent_verification_acceptance.py b/tests/v1_1/test_independent_verification_acceptance.py new file mode 100644 index 0000000..0935cbe --- /dev/null +++ b/tests/v1_1/test_independent_verification_acceptance.py @@ -0,0 +1,68 @@ +import copy +import json +from pathlib import Path +from threading import Event +from test_independent_verification_intake import service +from test_independent_verification_runner import imported +from test_independent_verification_rules import export +from test_verification_control import wait_idle + + +def test_end_to_end_mixed_batch_is_nonblocking_and_exports_same_evidence(service,tmp_path,monkeypatch): + from dx_productivity.trial_task_center import netlist_verification + from dx_productivity.trial_task_center.history_store import HistoryRepository + from dx_productivity.trial_task_center.retention import maintain_quick_run_storage + task,item=imported(service,tmp_path) + original=service.repo.revision(item,1)['payload'] + rows=[] + for key in ('rename','swap','missing'): + row={k:v for k,v in original.items() if k not in {'payload_digest','input_state'}};row['item_key']=key;row['display_name']=key + if key=='missing':row['before_ref']=None + rows.append(row) + service.publish_inputs(task,rows,submission_id='batch') + def native(capture,output,*,stop_event): + graph=export() + aid=output.parent.name;attempt=service.repo.attempt(aid);name=service.repo.item(attempt['item_id'])['display_name'] + if output.name=='after': + if name=='swap': + graph['graph']['components']['a']['pins']['loop']['number']='2';graph['graph']['components']['a']['pins']['GND']['number']='1' + if name=='rename': + graph['graph']['components']['a']['pins']['outloop']=graph['graph']['components']['a']['pins'].pop('loop') + graph['graph']['nets'][0]['endpoints'][0][1]='outloop' + return graph + monkeypatch.setattr(netlist_verification,'_export_saved_capture',native) + run=service.start(task,request_id='all');wait_idle(service) + summary=service.read_task(task)['summary'] + assert [summary[k] for k in ('consistent','warning','different','unavailable')]==[1,1,1,1] + report=service.export_task(task,tmp_path/'reports',request_id='report') + saved=json.loads((report/'task.json').read_text(encoding='utf-8')) + swapped=next(r for r in saved['items'] if r['display_name']=='swap') + assert swapped['attempt']['result']['verdict']=='DIFFERENT' + assert any(p['connection_changed'] for p in swapped['attempt']['result']['evidence']['pins']) + history=HistoryRepository(service.repo.store);assert history.page(query='工程校验').total==3 + snapshot=history.clear_snapshot();history.clear(snapshot.cutoff_id) + maintain_quick_run_storage(service.data_root,max_age_days=0,min_entries=0) + assert service.read_item(item)['status']=='consistent' + assert service.repo.store._connection.execute('SELECT COUNT(*) FROM execution_operations').fetchone()[0]==0 + + +def test_required_pin_text_does_not_claim_unread_pin_value_is_equal(): + from dx_productivity.trial_task_center.verification.rules import evaluate + from dx_productivity.trial_task_center.verification.contracts import default_plan + plan=default_plan();plan['optional_checks'].remove('pin_text');plan['required_checks'].append('pin_text') + assert evaluate(export(),export(),expectations=None,check_plan=plan)['verdict']=='INCOMPLETE' + + +def test_acceptance_cli_labels_controlled_format_evidence(tmp_path): + import subprocess,sys + from test_native_cli_netlist import project_fixture,graph + fixture=tmp_path/'fixture' + for phase in ('before','after'): + folder=fixture/phase;folder.mkdir(parents=True) + project_fixture(folder);graph(folder) + script=Path(__file__).parents[2]/'tools/verify_independent_verification.py' + result=subprocess.run([sys.executable,str(script),'--fixture-root',str(fixture),'--output',str(tmp_path/'acceptance')],capture_output=True,text=True,timeout=20) + assert result.returncode==0,result.stderr + summary=json.loads((tmp_path/'acceptance/acceptance.json').read_text(encoding='utf-8')) + assert summary['evidence_kind']=='controlled-format-fixture' and summary['inputs_unchanged'] + assert summary['replacement_operations']==0 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'] 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..816efb7 --- /dev/null +++ b/tests/v1_1/test_independent_verification_intake.py @@ -0,0 +1,188 @@ +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') + verification=VerificationService(store,tmp_path/'data') + try: yield verification + finally: + verification.begin_shutdown() + thread=verification.control.thread + if thread is not None:thread.join(10) + assert not verification.busy,'Verification must finish before its store is closed' + 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'] + + +def test_import_evidence_validation_does_not_hold_store_lock(service,tmp_path,monkeypatch): + from threading import Thread + 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='c')['task_id'] + read=service.artifacts.read;entered=Event();release=Event();created=Event();errors=[] + def slow(*args):entered.set();release.wait(5);return read(*args) + monkeypatch.setattr(service.artifacts,'read',slow) + def import_pair(): + try:service.import_pair(task,before,after,request_id='i',stop_event=Event()) + except Exception as error:errors.append(error) + worker=Thread(target=import_pair);worker.start();assert entered.wait(3) + creator=Thread(target=lambda:(service.create_task('另一个',request_id='other'),created.set()));creator.start() + try:assert created.wait(.5) + finally:release.set();worker.join(5);creator.join(5) + assert not errors + + +@pytest.mark.parametrize('failure',['cancel','invalid_name','second_capture']) +def test_unsuccessful_import_does_not_leave_unreferenced_captures(service,tmp_path,monkeypatch,failure): + folders=[tmp_path/phase for phase in ('before','after')] + for folder in folders: + folder.mkdir() + before,after=map(project_fixture,folders) + task=service.create_task('导入',request_id='task')['task_id'] + stop=Event() + from dx_productivity.trial_task_center import native_netlist + capture=native_netlist.capture_project + + def interrupt(project,destination): + result=capture(project,destination) + if failure=='cancel': + stop.set() + if failure=='second_capture' and project==after: + raise OSError('after capture failed before publication') + return result + + monkeypatch.setattr(native_netlist,'capture_project',interrupt) + if failure=='invalid_name': + result=service.import_pair(task,before,after,request_id='pair',stop_event=stop,display_name='x'*257) + assert result['rejected'] and not result['accepted'] + else: + with pytest.raises(TaskCenterError if failure=='cancel' else OSError): + service.import_pair(task,before,after,request_id='pair',stop_event=stop) + assert service.read_task(task)['items']==[] + assert not list(service.artifacts.root.glob('*')) + + +@pytest.mark.parametrize('initial',['ready','missing_evidence','fallback']) +def test_handoff_updates_same_project_and_never_replays_an_old_notification(service,tmp_path,initial): + from dx_productivity.trial_task_center.native_netlist import capture_project, _hash + evidence={} + for phase in ('before','after','retry'): + source=tmp_path/phase + source.mkdir() + project=project_fixture(source) + if phase=='retry': + (project.parent/'database/icdb.dat').write_bytes(b'after retry') + capture=capture_project(project,service.data_root/phase/'capture') + path=service.data_root/phase/'export.json' + path.write_text(json.dumps({'capture':capture}),encoding='utf-8') + evidence[phase]={'export_path':str(path),'export_sha256':_hash(path)} + report={'project_path':'board.prj','execution':{'state':'completed','saved_items':1}} + if initial=='ready': + report.update(before=evidence['before'],after=evidence['after'],expected_changes={}) + first_receipt={'run_id':'run','netlist_verification':{'board':report}} + if initial=='fallback': + first_receipt={'run_id':'run','tasks':[{'task_id':'board','name':'Board task', + 'state':'completed','saved_items':1}]} + first=service.receive_successful_results(first_receipt,submission_id='initial') + item=first['accepted'][0]['item_id'] + retry_report=dict(report,before=evidence['before'],after=evidence['retry'], + expected_changes={'u1':{'Value':'NEW'}},execution={'state':'completed','saved_items':2}) + retry_receipt=dict(first_receipt,netlist_verification={'board':retry_report}) + if initial=='ready': + with service.repo.store.transaction(): + service.repo._remember('handoff','retry',retry_receipt, + {'accepted':[],'rejected':[{'code':'verification_conflict'}]}) + second=service.receive_successful_results(retry_receipt,submission_id='retry') + assert second['accepted']==[{'item_id':item,'input_version':2}] + original=service.read_item(item,version=1)['payload'] + current=service.read_item(item)['payload'] + if initial=='ready': + assert current['before_ref']==original['before_ref'] + assert current['after_ref']!=original['after_ref'] + assert current['input_state']=='ready' + assert service.receive_successful_results(retry_receipt,submission_id='checkpoint')['duplicates']==second['accepted'] + service.receive_successful_results(first_receipt,submission_id='late-checkpoint') + assert service.read_item(item)['versions']==[2,1] + updated_report=dict(retry_report,expected_changes={'u1':{'Value':'NEWER'}}) + updated_receipt=dict(first_receipt,netlist_verification={'board':updated_report}) + third=service.receive_successful_results(updated_receipt,submission_id='latest') + assert third['accepted']==[{'item_id':item,'input_version':3}] + assert service.read_item(item)['payload']['before_ref']==current['before_ref'] 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..0336c49 --- /dev/null +++ b/tests/v1_1/test_independent_verification_queries.py @@ -0,0 +1,70 @@ +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'}) + + +def test_slow_evidence_read_does_not_lock_task_creation(repo): + from threading import Event,Thread + from dx_productivity.trial_task_center.verification.queries import VerificationQueries + task=repo.create_task('读取',request_id='c')['task_id'] + item=repo.publish(task,(payload(),),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'}) + entered=Event();release=Event();created=Event();q=VerificationQueries(repo) + def validate(_):entered.set();release.wait(3) + q.validator=validate + read=Thread(target=lambda:q.read_task(task));read.start();assert entered.wait(2) + writer=Thread(target=lambda:(repo.create_task('新任务',request_id='new'),created.set()));writer.start() + try:assert created.wait(.5) + finally:release.set();read.join(3);writer.join(3) + + +def test_previous_attempt_is_readable_without_replacing_current_result(repo): + from dx_productivity.trial_task_center.verification.queries import VerificationQueries + task=repo.create_task('历史',request_id='c')['task_id'] + item=repo.publish(task,(payload(),),submission_id='s')['accepted'][0]['item_id'] + attempts=[] + for n,verdict in enumerate(('DIFFERENT','CONSISTENT')): + a=repo.create_attempt(item,1,request_id=str(n));repo.claim(a['attempt_id'],owner_id='o') + repo.finish(a['attempt_id'],generation=a['generation'],result={'resource_state':'released','verdict':verdict});attempts.append(a) + q=VerificationQueries(repo) + assert q.read_item(item,attempt_id=attempts[0]['attempt_id'])['verdict']=='DIFFERENT' + assert q.read_item(item)['verdict']=='CONSISTENT' 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..ccb94a2 --- /dev/null +++ b/tests/v1_1/test_independent_verification_rules.py @@ -0,0 +1,107 @@ +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_empty_native_networks_cannot_prove_coverage(): + value=export() + value['graph']['nets']=[] + for component in value['graph']['components'].values(): + for pin in component['pins'].values(): + pin['nets']=[] + assert evaluate(value,value)['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'] + + +def test_duplicate_physical_number_introduced_is_hard_error(): + a=export();b=copy.deepcopy(a);b['graph']['components']['a']['pins']['loop']['number']='2' + result=evaluate(a,b) + assert result['verdict']=='DIFFERENT' + assert any(i['check_id']=='physical_pins' and i['state']=='error' for i in result['issues']) + + +def test_required_semantics_without_proven_type_is_incomplete(): + plan=default_plan();plan['optional_checks'].remove('pin_semantics');plan['required_checks'].append('pin_semantics') + assert evaluate(export(),export(),check_plan=plan)['verdict']=='INCOMPLETE' 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' 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..3653fe9 --- /dev/null +++ b/tests/v1_1/test_independent_verification_store.py @@ -0,0 +1,111 @@ +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() + + +def test_commit_acknowledgement_loss_can_be_retried_without_duplicates(repo,monkeypatch): + from contextlib import contextmanager + original=repo.store.transaction + fired=False + @contextmanager + def lost_reply(): + nonlocal fired + with original():yield + if not fired: + fired=True;raise OSError('lost response after commit') + with monkeypatch.context() as patch: + patch.setattr(repo.store,'transaction',lost_reply) + with pytest.raises(OSError):repo.create_task('持久结果',request_id='lost') + result=repo.create_task('持久结果',request_id='lost') + assert repo.task(result['task_id'])['name']=='持久结果' + assert repo.connection.execute('SELECT COUNT(*) FROM verification_tasks').fetchone()[0]==1 + + +def test_two_threads_cannot_claim_same_attempt(repo): + from concurrent.futures import ThreadPoolExecutor + task=repo.create_task('任务',request_id='c')['task_id'] + item=repo.publish(task,(payload(),),submission_id='s')['accepted'][0]['item_id'] + attempt=repo.create_attempt(item,1,request_id='a') + with ThreadPoolExecutor(2) as pool: + results=list(pool.map(lambda owner:repo.claim(attempt['attempt_id'],owner_id=owner),('one','two'))) + assert sum(row is not None for row in results)==1 diff --git a/tests/v1_1/test_verification_batch_import.py b/tests/v1_1/test_verification_batch_import.py new file mode 100644 index 0000000..7825be6 --- /dev/null +++ b/tests/v1_1/test_verification_batch_import.py @@ -0,0 +1,105 @@ +from threading import Event + +import pytest + +from test_independent_verification_intake import service +from test_native_cli_netlist import project_fixture + + +def project(root, relative): + folder = root / relative + folder.mkdir(parents=True) + return project_fixture(folder) + + +def test_preview_matches_relative_paths_and_lists_missing_sides(service, tmp_path): + before, after = tmp_path/'before', tmp_path/'after' + for root in (before, after): + project(root, 'A') + project(root, 'B') + project(before, 'removed') + project(after, 'added') + preview = service.preview_pairs(before, after, stop_event=Event()) + rows = {r['relative_path']: r for r in preview} + assert {key: row['status'] for key, row in rows.items()} == { + 'A/source/board.prj': 'ready', 'B/source/board.prj': 'ready', + 'added/source/board.prj': 'missing_before', 'removed/source/board.prj': 'missing_after'} + assert rows['A/source/board.prj']['before'] == str(before/'A/source/board.prj') + assert rows['A/source/board.prj']['after'] == str(after/'A/source/board.prj') + assert rows['B/source/board.prj']['after'] == str(after/'B/source/board.prj') + assert service.repo.connection.execute('SELECT COUNT(*) FROM verification_items').fetchone()[0] == 0 + + +@pytest.mark.parametrize('nested', [False, True]) +def test_preview_rejects_shared_or_nested_roots(service, tmp_path, nested): + before = tmp_path/'before' + before.mkdir() + after = before/'after' if nested else before + after.mkdir(exist_ok=True) + from dx_productivity.trial_task_center.errors import TaskCenterError + with pytest.raises(TaskCenterError): + service.preview_pairs(before, after, stop_event=Event()) + + +def test_batch_continues_after_bad_pair_and_repeated_submission_is_idempotent(service, tmp_path): + before, after = tmp_path/'before', tmp_path/'after' + left, right = project(before, 'A'), project(after, 'A') + other_left, other_right = project(before, 'B'), project(after, 'B') + task = service.create_task('批量', request_id='create')['task_id'] + pairs = ((left, right), (left, left), (other_left, other_right)) + result = service.import_pairs(task, pairs, request_id='batch', stop_event=Event()) + assert [r['status'] for r in result['rows']] == ['imported', 'failed', 'imported'] + assert result['processed'] == 3 and not result['cancelled'] + assert service.import_pairs(task, pairs, request_id='batch', stop_event=Event()) == result + assert service.repo.connection.execute('SELECT COUNT(*) FROM verification_items').fetchone()[0] == 2 + assert service.repo.connection.execute('SELECT COUNT(*) FROM verification_attempts').fetchone()[0] == 0 + + +def test_cancel_keeps_imported_items_and_same_request_can_resume_without_duplicates(service, tmp_path): + pairs = tuple((project(tmp_path/'before', str(n)), project(tmp_path/'after', str(n))) for n in range(3)) + task = service.create_task('取消', request_id='create')['task_id'] + stop = Event() + def progress(row, processed, total): + assert total == 3 + stop.set() + partial = service.import_pairs(task, pairs, request_id='batch', stop_event=stop, on_progress=progress) + assert partial['processed'] == 1 and partial['cancelled'] + assert service.repo.connection.execute('SELECT COUNT(*) FROM verification_items').fetchone()[0] == 1 + complete = service.import_pairs(task, pairs, request_id='batch', stop_event=Event()) + assert complete['processed'] == 3 and not complete['cancelled'] + assert service.repo.connection.execute('SELECT COUNT(*) FROM verification_items').fetchone()[0] == 3 + + +def test_batch_does_not_continue_writes_after_storage_exhaustion(service, tmp_path, monkeypatch): + import errno + pairs = tuple((project(tmp_path/'before', str(n)), project(tmp_path/'after', str(n))) for n in range(2)) + task = service.create_task('磁盘', request_id='create')['task_id'] + capture = service.artifacts.capture + def disk_full(path, **kwargs): + if str(path) == str(pairs[0][0]): + raise OSError(errno.ENOSPC, 'disk full', str(service.data_root/'verification')) + return capture(path, **kwargs) + monkeypatch.setattr(service.artifacts, 'capture', disk_full) + with pytest.raises(OSError): + service.import_pairs(task, pairs, request_id='batch', stop_event=Event()) + assert service.repo.connection.execute('SELECT COUNT(*) FROM verification_items').fetchone()[0] == 0 + + +def test_cancelled_request_cannot_be_reused_for_different_input(service, tmp_path): + pairs = ((project(tmp_path/'before', 'A'), project(tmp_path/'after', 'A')),) + task = service.create_task('请求绑定', request_id='create')['task_id'] + stop = Event(); stop.set() + service.import_pairs(task, pairs, request_id='batch', stop_event=stop) + from dx_productivity.trial_task_center.errors import TaskCenterError + with pytest.raises(TaskCenterError) as error: + service.import_pairs(task, (), request_id='batch', stop_event=Event()) + assert error.value.code == 'verification_conflict' + + +def test_rejected_display_name_is_not_reported_as_imported(service, tmp_path): + pairs = ((project(tmp_path/'before', 'A'), project(tmp_path/'after', 'A')),) + task = service.create_task('拒绝', request_id='create')['task_id'] + result = service.import_pairs(task, pairs, request_id='batch', stop_event=Event(), display_names=('x'*257,)) + assert result['rows'][0]['status'] == 'failed' + assert result['rows'][0]['reason'] + assert service.repo.connection.execute('SELECT COUNT(*) FROM verification_items').fetchone()[0] == 0 diff --git a/tests/v1_1/test_verification_closed_loop.py b/tests/v1_1/test_verification_closed_loop.py new file mode 100644 index 0000000..bd74d2f --- /dev/null +++ b/tests/v1_1/test_verification_closed_loop.py @@ -0,0 +1,138 @@ +import copy +import json +from pathlib import Path +from threading import Event +import pytest + +from test_independent_verification_intake import service +from test_independent_verification_runner import imported +from test_native_cli_netlist import graph +from test_verification_control import wait_idle + + +def complete(service, tmp_path, monkeypatch): + from tools.verification_closed_loop import freeze_inputs + from dx_productivity.trial_task_center import netlist_verification + task, item = imported(service, tmp_path) + scope = freeze_inputs(service, task, expected_count=1) + def native(capture, output, *, stop_event): + output.mkdir(parents=True, exist_ok=True) + return {'status': 'success', 'complete': True, 'capture': capture, 'graph': graph(output), + 'outputs': {'effective': str(output/'effective.txt'), 'keyin': str(output/'design.kyn')}} + monkeypatch.setattr(netlist_verification, '_export_saved_capture', native) + run = service.start(task, request_id='loop-start'); wait_idle(service) + report = service.export_task(task, tmp_path/'reports', request_id='loop-report') + return task, item, scope, run, report + + +def test_complete_scope_report_and_inputs_pass_same_attempt_checks(service, tmp_path, monkeypatch): + from tools.verification_closed_loop import verify_closed_loop + task, item, scope, run, report = complete(service, tmp_path, monkeypatch) + result = verify_closed_loop(service, task, scope, run, report, expected_verdicts={item: 'CONSISTENT'}) + assert result['passed'] and all(c['state']=='passed' for c in result['checks']) + + +def test_empty_task_cannot_be_frozen_as_a_closed_loop(service): + from tools.verification_closed_loop import freeze_inputs + task = service.create_task('空', request_id='empty')['task_id'] + with pytest.raises(ValueError): freeze_inputs(service, task, expected_count=0) + + +@pytest.mark.parametrize('fault', ['run_member', 'report_attempt', 'html_binding', 'source', 'expected_verdict', 'resource_proof', 'evidence_binding']) +def test_closed_loop_rejects_wrong_members_stale_reports_and_changed_sources(service, tmp_path, monkeypatch, fault): + from tools.verification_closed_loop import verify_closed_loop + task, item, scope, run, report = complete(service, tmp_path, monkeypatch) + expected = {item: 'CONSISTENT'} + if fault=='run_member': + run = copy.deepcopy(run); run['members'] = [] + elif fault=='report_attempt': + path = report/'task.json'; value = json.loads(path.read_text(encoding='utf-8')) + value['items'][0]['attempt_id'] = 'old-attempt' + path.write_text(json.dumps(value), encoding='utf-8') + elif fault=='html_binding': + path = report/f'{item}-v1.html'; path.write_text('CONSISTENT', encoding='utf-8') + elif fault=='source': + capture = service.artifacts.read(scope['items'][0]['before_ref'], 'snapshot') + Path(capture['project']).write_text('changed', encoding='utf-8') + elif fault=='expected_verdict': + expected[item] = 'DIFFERENT' + elif fault=='resource_proof': + attempt = service.repo.latest_attempt(item, 1) + (service.data_root/'verification/attempts'/attempt['attempt_id']/'resource-released.json').write_text( + json.dumps({'owner_id': 'another-owner', 'resource_state': 'released'}), encoding='utf-8') + else: + path = report/'task.json'; value = json.loads(path.read_text(encoding='utf-8')) + value['items'][0]['attempt']['result']['evidence']['binding']['input_digest'] = 'f'*64 + path.write_text(json.dumps(value), encoding='utf-8') + result = verify_closed_loop(service, task, scope, run, report, expected_verdicts=expected) + assert not result['passed'] and any(c['state']=='failed' for c in result['checks']) + + +def test_stopped_attempt_is_not_a_completed_closed_loop(service, tmp_path): + from tools.verification_closed_loop import freeze_inputs, verify_closed_loop + task, item = imported(service, tmp_path) + scope = freeze_inputs(service, task, expected_count=1) + attempt = service.repo.create_attempt(item, 1, request_id='cancelled') + service.repo.finish(attempt['attempt_id'], generation=attempt['generation'], result={ + 'attempt_state': 'cancelled', 'resource_state': 'released', 'verdict': 'INCOMPLETE', 'reason': 'stop'}) + run = {'run_id': None, 'members': [{'item_id': item, 'input_version': 1, 'attempt_id': attempt['attempt_id']}]} + report = service.export_task(task, tmp_path/'reports', request_id='cancelled-report') + result = verify_closed_loop(service, task, scope, run, report, expected_verdicts={item: 'INCOMPLETE'}) + assert not result['passed'] + + +def test_selected_rerun_is_checked_against_its_scope_inside_a_whole_task_report(service, tmp_path, monkeypatch): + from tools.verification_closed_loop import freeze_inputs, verify_closed_loop + task, item, _, _, _ = complete(service, tmp_path, monkeypatch) + payload = {key: value for key, value in service.repo.revision(item, 1)['payload'].items() + if key not in ('payload_digest', 'input_state')} + payload.update(item_key='second', display_name='second') + service.publish_inputs(task, (payload,), submission_id='second') + scope = freeze_inputs(service, task, expected_count=2) + whole = service.start(task, selection=tuple((row['item_id'], 1) for row in scope['items']), request_id='whole-task'); wait_idle(service) + subset = dict(scope, items=[row for row in scope['items'] if row['item_id']==item]) + selected_run = dict(whole, members=[row for row in whole['members'] if row['item_id']==item]) + whole_report = service.export_task(task, tmp_path/'whole-report', request_id='whole-report') + assert verify_closed_loop(service, task, subset, selected_run, whole_report, expected_verdicts={item: 'CONSISTENT'}, selected_only=True)['passed'] + run = service.rerun(item, 1, request_id='selected'); wait_idle(service) + scope['items'] = [row for row in scope['items'] if row['item_id']==item] + report = service.export_task(task, tmp_path/'selected-report', request_id='selected-report') + result = verify_closed_loop(service, task, scope, run, report, expected_verdicts={item: 'CONSISTENT'}, selected_only=True) + assert result['passed'] + assert not verify_closed_loop(service, task, scope, run, report, expected_verdicts={item: 'CONSISTENT'})['passed'] + + +def test_existing_replacement_history_is_allowed_but_new_replacement_is_rejected(service, tmp_path, monkeypatch): + from tools.verification_closed_loop import verify_closed_loop + def operation(key): + with service.repo.store.transaction(): + service.repo.connection.execute('''INSERT INTO execution_operations + (task_id,round_id,operation_key,command_json,state) VALUES ('prior','round',?,'{}','verified')''', (key,)) + operation('before-verification') + task, item, scope, run, report = complete(service, tmp_path, monkeypatch) + assert verify_closed_loop(service, task, scope, run, report, expected_verdicts={item: 'CONSISTENT'})['passed'] + with service.repo.store.transaction(): + service.repo.connection.execute("UPDATE execution_operations SET generation=1 WHERE operation_key='before-verification'") + assert not verify_closed_loop(service, task, scope, run, report, expected_verdicts={item: 'CONSISTENT'})['passed'] + with service.repo.store.transaction(): + service.repo.connection.execute("UPDATE execution_operations SET generation=0 WHERE operation_key='before-verification'") + operation('during-verification') + assert not verify_closed_loop(service, task, scope, run, report, expected_verdicts={item: 'CONSISTENT'})['passed'] + + +def test_saved_handoff_freezes_current_source_without_reinventing_historical_before(service, tmp_path): + from tools.verification_closed_loop import freeze_inputs + from test_native_cli_netlist import project_fixture + folder=tmp_path/'live';folder.mkdir();path=project_fixture(folder) + before=service.artifacts.capture(path,stop_event=Event()) + (path.parent/'database/icdb.dat').write_bytes(b'saved-after') + after=service.artifacts.capture(path,stop_event=Event()) + expected=service.artifacts.put('expectations',{'changes':{}}) + from dx_productivity.trial_task_center.verification.contracts import default_plan + task=service.create_task('交接',request_id='handoff')['task_id'] + service.publish_inputs(task,({'item_key':'saved','project_key':str(path),'input_version':1, + 'before_ref':before,'after_ref':after,'expectation_ref':expected,'check_plan':default_plan()},),submission_id='saved') + with pytest.raises(ValueError):freeze_inputs(service,task,expected_count=1) + scope=freeze_inputs(service,task,expected_count=1,historical_before=True) + assert scope['historical_before'] is True + assert service.artifacts.read(before,'snapshot')['source_hashes']!=scope['source_hashes'] diff --git a/tests/v1_1/test_verification_control.py b/tests/v1_1/test_verification_control.py new file mode 100644 index 0000000..fbcd37f --- /dev/null +++ b/tests/v1_1/test_verification_control.py @@ -0,0 +1,169 @@ +import time +from threading import Event +import pytest +from dx_productivity.trial_task_center.errors import TaskCenterError +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()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/tests/v1_1/test_verification_reports.py b/tests/v1_1/test_verification_reports.py new file mode 100644 index 0000000..945fe06 --- /dev/null +++ b/tests/v1_1/test_verification_reports.py @@ -0,0 +1,109 @@ +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 '