From 40fbb1893aaea512eff84ea75eecd2b48766e07e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=98=BF=E7=99=BD=E5=8F=94?= <11794527+absfan@user.noreply.gitee.com> Date: Fri, 6 Nov 2026 14:51:19 +0800 Subject: [PATCH] Add portable Mentor schematic batch exporter --- .gitignore | 8 + README.md | 51 ++ .../plans/2026-11-06-batch-export.md | 57 ++ .../specs/2026-11-06-batch-export.md | 154 ++++ docs/validation-2026-11-06.md | 35 + export.py | 16 + helpers/build_native.cmd | 6 + helpers/constraints_read.vbs | 91 +++ helpers/native_read.cpp | 216 ++++++ helpers/native_read.exe | Bin 0 -> 142336 bytes mentorexport/__init__.py | 2 + mentorexport/_desktop.py | 698 ++++++++++++++++++ mentorexport/_errors.py | 29 + mentorexport/_identity.py | 77 ++ mentorexport/cli.py | 332 +++++++++ mentorexport/core.py | 133 ++++ mentorexport/environment.py | 178 +++++ mentorexport/exports.py | 656 ++++++++++++++++ mentorexport/report.py | 72 ++ packaging/accept_portable.py | 94 +++ packaging/build_portable.py | 126 ++++ tests/test_cli.py | 71 ++ tests/test_core.py | 74 ++ tests/test_environment.py | 29 + tests/test_exports.py | 401 ++++++++++ 导出.cmd | 16 + 26 files changed, 3622 insertions(+) create mode 100644 .gitignore create mode 100644 README.md create mode 100644 docs/superpowers/plans/2026-11-06-batch-export.md create mode 100644 docs/superpowers/specs/2026-11-06-batch-export.md create mode 100644 docs/validation-2026-11-06.md create mode 100644 export.py create mode 100644 helpers/build_native.cmd create mode 100644 helpers/constraints_read.vbs create mode 100644 helpers/native_read.cpp create mode 100644 helpers/native_read.exe create mode 100644 mentorexport/__init__.py create mode 100644 mentorexport/_desktop.py create mode 100644 mentorexport/_errors.py create mode 100644 mentorexport/_identity.py create mode 100644 mentorexport/cli.py create mode 100644 mentorexport/core.py create mode 100644 mentorexport/environment.py create mode 100644 mentorexport/exports.py create mode 100644 mentorexport/report.py create mode 100644 packaging/accept_portable.py create mode 100644 packaging/build_portable.py create mode 100644 tests/test_cli.py create mode 100644 tests/test_core.py create mode 100644 tests/test_environment.py create mode 100644 tests/test_exports.py create mode 100644 导出.cmd diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..7247536 --- /dev/null +++ b/.gitignore @@ -0,0 +1,8 @@ +runtime/ +dist/ +build/ +__pycache__/ +.pytest_cache/ +.superpowers/ +*.pyc +settings.json diff --git a/README.md b/README.md new file mode 100644 index 0000000..afa6416 --- /dev/null +++ b/README.md @@ -0,0 +1,51 @@ +# MentorExport 原理图批量导出 + +解压整个工具文件夹后,双击「导出.cmd」,或在命令提示符中运行它。Python 和必要包已经预置,使用者无需安装 Python、pip 或设置环境变量。需要本机已有 Mentor 安装及对应可用许可。 + +## 第一次使用 + +1. 保存需要导出的原理图。 +2. 启动「导出.cmd」。自动发现 Mentor;有多套时选择版本。 +3. 输入工程根目录,递归扫描 .prj;输入结果根目录。 +4. 核对数量与原理图快照后确认。完成后可直接打开汇总、结果目录,或重试未完成项。 + +默认读取工程指定的原理图快照,通常是 DxD。工具不打开 Designer,不执行换料或 PCB 同步。源数据库只用于捕获稳定副本,各导出器在私有副本中运行。 + +## 命令行 + + 导出.cmd + 导出.cmd --check + 导出.cmd --input "F:\工程目录" --output "F:\导出结果" --yes + 导出.cmd --mentor-home "D:\Mentor\7.9.5EE\SDD_HOME" --input "F:\工程目录" --yes + 导出.cmd --retry "F:\导出结果\批次_..." --yes + +不指定参数进入问答。--yes 适合使用固定参数重复运行;发现多套 Mentor 时需要 --mentor-home 指定。--timeout 可以调整单工具等待上限,默认 60 秒。 + +按 Ctrl+C 请求停止,等待工具收尾;不要直接关闭窗口。下次使用 --retry 指定批次,可恢复未完成项。成功产物只有在输入、工具和输出摘要仍匹配时才复用;源工程变化会完整重新导出该工程。 + +退出码:0 全部请求项成功;1 含扫描问题/部分成功/失败;2 环境或输入配置错误;130 已取消。 + +## 输出内容 + +每次建立独立批次,不覆盖旧结果。工程目录包含: + +- 01_连接网表:KeyinNetlist、RinfNetlist、EDIF Netlist、PXR。 +- 02_器件与引脚属性:ASCII 平铺有效值、分层值、CSV 关联表、WIR/OAT。 +- 03_位置与显示:EDIF Schematic。 +- 04_电气约束:CMS 约束记录、单位、默认值及覆盖标记。 +- 05_关联库件与封装:当前工程用到的库件/封装数据和索引。同库数据按指纹在批次内共享。 +- 90_运行日志:工具输出、参数、错误及收尾记录。 + +工具、模式、快照、输入/输出摘要分别保存。同名字段不互相覆盖;分层属性、平铺有效值、网表身份表和当前中央库是不同来源。先看「导出汇总.html」,再进入工程的逐项说明。 + +“成功”表示请求的导出项生成并通过产物检查,不代表换料正确、ERC 通过或全部制造几何已核验。缺工具、COM 不匹配、缺库或不支持的内容均明确列出,不使用空文件冒充成功。 + +## 兼容与边界 + +面向 Windows 10/11 x64。本地原生库读取 ABI 首先支持实测 EE7.9.5 DLL 指纹;其他安装可被发现,但不盲调未验证的库 ABI。Python 运行时、依赖与完整性清单见 runtime-dependencies.json、package-manifest.json。不要只复制启动脚本,须保留整个文件夹。 + +多根配置暂列为需明确处理的工程,不静默选择第一个。装配变体、完整字体族、钻孔/阻焊几何、复杂多 gate/可交换脚的覆盖以报告为准,不能仅凭文件生成判断已取得全部内部信息。 + +## 开发与复现 + +源码为 export.py、mentorexport 和 helpers。Python 测试使用 pytest;packaging/build_portable.py 构建预置环境和 ZIP。构建过程中从 Python.org/PyPI 下载锁版本组件,使用者运行时无需网络。厂商 EXE/DLL 不随工具分发。 diff --git a/docs/superpowers/plans/2026-11-06-batch-export.md b/docs/superpowers/plans/2026-11-06-batch-export.md new file mode 100644 index 0000000..92b9edd --- /dev/null +++ b/docs/superpowers/plans/2026-11-06-batch-export.md @@ -0,0 +1,57 @@ +# Mentor Batch Export Implementation Plan + +> For agentic workers: use superpowers:subagent-driven-development. Steps use checkbox syntax. + +Goal: ship an offline portable, interactive Windows folder exporter for saved Mentor schematics, with tool provenance and recoverable results. + +Architecture: a standalone Python package, bundled embedded Python and pywin32, vendor tools discovered locally. The CLI owns batching and reports; the exporter owns stable clones, isolated tool execution, validation and shared library reads. + +Tech Stack: Python 3.12 x64, pywin32 312, x86 native library helper, 32-bit Windows cscript, stdlib HTML/JSON. + +Spec: ../specs/2026-11-06-batch-export.md, approved by the user in chat. + +## Global Constraints + +- No Designer launch, no mutation of source projects/libraries or permanent environment/COM registration changes. +- Detailed schematic exports by default. Tool and mode provenance never merged away. +- Portable Python with preset dependencies; no user-side pip. +- Source copies exclude server address files. Owned native process cleanup is mandatory. +- Failure/partial/unavailable/cancelled must be visible; output validation required even with exit code zero. +- Retrying a changed source starts a complete new project attempt, never mixes source generations. + +## Interfaces shared by tasks + +core.read_project(path) returns a dict with string path, name, database, root_block, snapshot, library (str or None). +core.sha256(path), core.read_text(path), core.write_json(path, value) are stdlib utilities. +environment.discover_installations(explicit=None, cached=None) returns root/version/tools/native_compatible/com dicts. +tools keys are ascii, csv, keyin, rinf, edif, wir, pxr, constraints_xml; values are absolute EXE paths. +installation.com maps cms and central to dicts containing registered_path and matches. +exports.export_project(project, installation, project_dir, shared_dir, *, previous=None, stop_event=None, timeout=45, progress=print) returns a JSON-serializable record containing status, source_fingerprint, items, and source_hashes. +Each item has key, status (success/failed/unavailable/cancelled), reason, outputs (absolute file paths), and provenance. +previous is an earlier exporter result; project_dir is always a new attempt directory. Successful prior items are reused only when hashes, snapshot and tool identity still match. +exports.list_snapshots(project, installation, work_dir) may return names, without changing default selection. + +## Task 1: export backend and helpers + +- [x] Write behavioral tests for exit-zero/no-output, stable clones, cancellation, tool provenance and changed-input retries; run red. +- [x] Implement exports.py, helpers, and private process boundary by reusing verified research code; no fixed sample root/path. +- [x] Preserve ASCII flat/hier, CSV tables, WIR/OAT, KYN/RINF/PXR, EDIF net/schematic, CMS constraints with level identity. +- [x] Export associated library data for used parts/cells once per matching library fingerprint; native ABI guard and clear partial coverage. +- [x] Run tests green and report touched files and limitations. + +## Task 2: environment, scanning, CLI, reporting + +- [x] Write failing filesystem/behavior tests before implementation. +- [x] Implement core.py with project options, recursive discovery, collision-safe names, bounded identity and stable capture utilities. +- [x] Implement environment.py with explicit/cache/env/registry/limited conventional paths; same-install tools and COM matching. +- [x] Implement export.py interactive/noninteractive CLI, settings, per-batch and per-project manifests, cancellation, retries and HTML summaries. +- [x] Verify output-root recursion exclusion, duplicate names, invalid sources, changed sources and late interruption records. + +## Task 3: portable package and acceptance + +- [x] Build embedded Python 3.12.10 x64 from official distributable, preset locked pywin32 wheel, include runtime/third-party licenses. +- [x] Compile custom helper x86 with static CRT; include source, no Mentor binaries. +- [x] Create CMD entry using only relative bundled runtime; integrity validation and offline smoke check. +- [x] Run a real two-project export, compare source hashes, inspect provenance and required artifacts, retry selected failed/unavailable items. +- [x] Test moved folder with Python/PATH environment stripped; timeout/cancel/error tests; independent review. +- [x] Deliver folder and ZIP with README, dependency/compatibility manifest and validation report. diff --git a/docs/superpowers/specs/2026-11-06-batch-export.md b/docs/superpowers/specs/2026-11-06-batch-export.md new file mode 100644 index 0000000..12e350e --- /dev/null +++ b/docs/superpowers/specs/2026-11-06-batch-export.md @@ -0,0 +1,154 @@ +# Mentor 批量原理图导出工具设计草案 + +日期:2026-11-06。状态:已获用户确认并实施;最终验收见 ../../validation-2026-11-06.md。 + +## 已确认要求 + +- 独立、可复制的工具文件夹,以命令行启动,中文问答式交互。 +- 递归扫描用户指定目录中的 Mentor 工程。 +- 默认 A「工程详细包」,默认读取工程配置指定的原理图快照,通常是 DxD。 +- 不同工具、同一工具的不同模式分别保存,不能把同名字段直接合并为同一事实。 +- 导出集中到一个结果根目录,按批次、工程名称及重要内容分类。 +- 自动发现 Mentor 环境。 +- Python 环境及必要依赖预置好,用户端无需 pip 安装。 +- 注重重复运行、结果核实、失败说明及重试。 + +以下为建议细则,不将其标记为用户已经逐项确认。 + +## 交付和运行环境 + +交付 ZIP,解压为工具文件夹: + + MentorExport/ + 导出.cmd + export.py + runtime/ 便携 Python 3.12 x64 及预装依赖 + helpers/ 自有 x86 库读取 EXE、VBS 和进程隔离模块 + licenses/ + 使用说明.md + +第一版以 Windows 10/11 x64 为目标,脚本可读、可维护。命令入口始终调用随包 runtime/python.exe,不依赖系统 Python、PATH 或 Python Launcher。必要的 pywin32 模块及原生 DLL 一起预置并固定版本;不引入界面框架。自有库读取程序按 x86 构建,CMS 和 CentralLib 的 VBS 使用 Windows 自带 32 位 cscript。 + +构建时形成依赖版本、文件和 SHA256 清单;启动验证运行环境,缺失/损坏时给出具体文件和恢复方法,不在用户端自动联网安装。发布包不携带 Mentor 厂商 EXE/DLL;目标机器必须已有可用 Mentor 安装及相应许可。必要运行时依赖在预检中实际检查。 + +保留一个用户配置文件,记住上次输入/输出路径及已选择的 Mentor 安装。优先保存到可写的工具目录;工具目录不可写时使用 LOCALAPPDATA/MentorExport。复制到另一电脑后,安装路径必须重新验证。设置仅限本工具,不永久修改用户环境变量或系统 COM 注册。 + +## Mentor 环境自动发现 + +按以下来源收集候选,规范化路径后去重: + +1. 本次命令指定路径、上次选定且仍有效的路径。 +2. 当前进程的 SDD_HOME。 +3. 32/64 位注册表中的相关安装项、卸载信息和已注册组件路径。 +4. 常见安装根目录下的有限层级目录查找,不默认递归扫描所有磁盘。 +5. 自动发现失败时,提示用户输入安装目录。 + +每个候选核验安装根、工具文件、版本、必要依赖和导出参数能力。单个 EXE 存在不代表该安装完整。工具和依赖必须来自同一套安装,不能拼凑多个版本的 PATH。 + +只找到一套可用安装时默认选用;多套时展示版本、路径和可用导出项,让用户选一次并记住。只有本机已验证的 EE7.9.5 接口能够默认使用原生库读取 helper;其他版本需通过明确的兼容准入,未验证项展示为不可用,不盲调本机 ABI。 + +CMS/CentralLib 的 32 位 COM 注册路径要与选定安装匹配。发现其他版本注册时,不自动重新注册,相关导出项返回可解释的不可用状态;其他独立导出继续。 + +环境预检只调用已有帮助/能力接口,不启动 Designer;不因探测而打开用户工程。 + +## 交互流程 + +1. 启动自检,显示本工具、运行环境与 Mentor 版本,以及缺失能力。 +2. 输入扫描根目录,可回车沿用上次路径。 +3. 递归发现 .prj,验证其数据库、根块及原理图快照;展示发现数、可导出数和问题工程。 +4. 输入输出根目录,默认给出独立的导出结果目录;避免将输出放进源数据库。 +5. 显示摘要:工程数、输出位置、原理图快照策略、可用/缺失导出项。用户确认后开始。 +6. 按工程、按导出项顺序执行,持续显示当前工程、步骤和已完成数量。 +7. 完成后显示成功、部分成功、失败、取消数量、汇总报告路径和下一步菜单:打开结果目录、查看失败、仅重试失败项、退出。 + +命令行同时支持指定输入、输出和 Mentor 安装路径,以减少重复输入;未提供的必要参数继续问答。完整脚本重跑与失败项重试是明确区分的操作。暂不增加无人值守调度、任务数据库或界面。 + +## 工程发现与命名 + +以规范化后的 .prj 路径识别工程,不把 .dxp 与旁边 .prj 重复计数。只发现 .dxp 时提示未找到对应可用 .prj,不自动启动 Designer 做转换。 + +同名工程保留原工程名并追加源相对路径摘要,避免覆盖或混淆。扫描不进入本工具已有导出目录、私有临时目录、.git 或目录联接/符号链接;其他目录不按宽泛名称随意排除。访问失败单独列出,不静默漏掉子目录。 + +默认从工程配置取得原理图快照及根块;其他快照仅记录名称。一个 .prj 下存在多个根块/配置时要显式枚举和区分,无法确定原理图上下文时列为需选择/不支持,不能静默挑第一个。快照不能称为装配变体。 + +## 结果目录 + + 导出结果/ + 批次_日期时间_短标识/ + 导出汇总.html + 批次记录.json + 环境信息.json + 工程A/ + 工程说明.html + 工程记录.json + 01_连接网表/ + KeyinNetlist/ + RinfNetlist/ + EDIF_Netlist/ + PXR/ + 02_器件与引脚属性/ + icdb2ascii_平铺有效值/ + icdb2ascii_分层值/ + icdb2csv/ + WIR_OAT/ + 03_位置与显示/ + EDIF_Schematic/ + 04_电气约束/ + CMS/ + 05_关联库件与封装/ + 工程引用与数据索引.json + 90_运行日志/ + _共享库数据/ + 库指纹/ + +目录示意是完整能力集;某一项不可用时,在记录及工程说明中明确写原因,不生成会误导用户的空成功文件。 + +所有原始输出按工具和模式保留;同一字段来自工程平铺、分层、网表身份列或中央库时,分别标注。报告可以引用和并列展示,不能自动覆盖差异或把旧网表身份列改写成当前料号。 + +工程记录保存:源路径、捕获时间、输入哈希、根块/快照/配置、工具版本与指纹、参数、退出码、耗时、产物路径/大小/哈希、完整性检查、覆盖限制和错误。 + +默认结果使用已验证、可读的导出路线。编码的 HKP/约束 XML、CCZ 等研究产物不默认加入,避免用文件存在冒充字段已覆盖。 + +## 工程详细包的范围 + +连接:KYN、RINF、EDIF Netlist、PXR。属性:平铺/分层 ASCII、CSV 关联表、WIR/OAT。显示:EDIF Schematic 的实际导出内容。约束:CMS 原始记录、列约束定义、单位及默认/覆盖标记。 + +关联库以本批工程实际使用的料号和封装为范围;同一库按指纹共享读取与结果,避免每工程保存整套中央库。缺库、库件重名、关联不明确或不支持的脚号映射分别记为未取得/无法确认。不能将未验证的多 gate、多 slot、可交换脚或历史库版本映射标为通过。 + +脚本只执行导出与覆盖检查,输出不等于换料前后比较,也不等于 ERC/制造正确性认证。第一版不加入自动修图、换料或 PCB 同步。 + +## 隔离、重复运行和失败闭环 + +- 每工程先捕获稳定的已保存输入,工具只访问短路径私有副本;不复制数据库服务器地址文件。所有导出项使用同一捕获输入,必要时每工具再建运行副本。 +- 校验源文件读取前后摘要与副本摘要。数据库不可读或捕获期间变化时,该工程失败并给出保存后重试提示,不强行读取编辑中的不一致状态。 +- 子进程环境临时设置 SDD_HOME、SDD_PLATFORM、同安装 DLL 路径。私有桌面和 Job 管理自有进程,保留超时、退出及资源收尾证据。 +- 一个导出项失败,独立项继续;一个工程失败,其他工程继续。停止时先收尾当前工具,未执行项显示取消。 +- 新运行创建新批次,旧结果不覆盖。重试建立独立尝试目录,旧失败证据保留;未变的成功输出可以引用,不能冒充重新导出。 +- 仅当工程和所需库指纹仍匹配,才允许只重试失败项;输入已变时创建该工程的新完整尝试,避免混合前后状态。 +- 启动时识别未完成尝试并显示中断状态;确认旧自有进程已退出后,允许重试,不默认自动续跑。 +- 临时目录只清理本工具确认为自有、且进程已收尾的路径;日志和已发布产物保留。 + +## 结果判定 + +导出项:成功、失败、不可用、取消。成功必须同时满足可接受退出码、预期产物存在、非空/格式要求、对应快照和最小完整性检查;不能只看退出码为 0。 + +工程:全部请求项成功才为成功;有成功也有失败/不可用为部分成功;没有可用结果为失败;被停止且未执行完为取消。覆盖限制始终单独展示。 + +进程退出码建议:0 全部请求成功;1 已完成但含部分成功/失败;2 启动配置或必需环境错误;130 用户取消。HTML 和 JSON 结果始终与退出码一致。 + +## 实施顺序草案 + +1. 搭好独立交付目录和预置运行环境;完成可从任意工作目录启动的命令入口、离线依赖自检及 Mentor 发现。 +2. 完成问答、目录扫描、工程身份/配置解析和稳定输入副本。 +3. 按来源接入现有可读导出路线;补齐工程根块、快照和路径参数,移除研究脚本的固定样例路径。 +4. 完成工程所用库件/封装读取与共享指纹索引、来源标注及覆盖报告。 +5. 完成汇总页、状态、取消/超时、失败重试和中断识别。 +6. 打包并在清理 Python/PATH 环境的子进程中验收便携启动;使用真实工程副本完成端到端验证。 + +正式实施计划将在本草案定稿后细化到文件、接口、测试与验收步骤。 + +## 验收重点 + +干净环境启动(无系统 Python/pip/PATH 依赖)、中文/空格/长路径、单套/多套/失效 Mentor 路径、32 位 COM 路径不匹配、无工程、重名工程、不可访问目录、源输入变化、缺库、非零退出、退出 0 无产物、超时、取消、中断、仅重试失败、输入变更后的重试。 + +真实导出验收须逐项核对报告、原始产物、来源标识与输入哈希,确认没有启动 Designer,没有修改源工程/源库,并证明复制整个交付文件夹到另一目录后仍能运行。 diff --git a/docs/validation-2026-11-06.md b/docs/validation-2026-11-06.md new file mode 100644 index 0000000..09ea9be --- /dev/null +++ b/docs/validation-2026-11-06.md @@ -0,0 +1,35 @@ +# MentorExport 0.1.0 发布验收 + +日期:2026-11-06。本机实际环境:Windows x64、Mentor EE7.9.5。 + +交付:`F:\MentorExport-0.1.0-final` 和同名 ZIP,约 18.3 MB。Python 3.12.10 amd64、pywin32 312 已预置;Mentor 程序和 DLL 由本机发现,不随包分发。 + +## 已验证 + +- 完整自动测试:`python -X utf8 -m pytest -q`,40 passed in 19.66s。 +- 独立审查最初发现的源路径保护、清理不确定性、坐标空值、错误证据保留等问题均已修正;末轮审查无待处理发现。 +- 将最终包复制到中文及空格路径,从 `C:\Windows\Temp` 调用真实 `导出.cmd`。PATH 仅为 `C:\WINDOWS\System32`,PYTHONHOME/PYTHONPATH 设置为无效目录,实际使用随包 Python,环境自动发现及预检成功。 +- 驱动无参数中文问答:输入扫描目录、结果目录、确认和退出。递归找到两份同名工程,目录名通过摘要区分。 +- 两个真实原理图工程:Audio-D2128、Audio-T605A。输入路径长度分别为 80、315 字符,包含中文及空格。 +- 完整导出耗时 128.75 秒;两工程各 11 项成功,退出码 0。ASCII 平铺/分层、CSV、WIR/OAT、KYN、RINF、PXR、两种 EDIF、CMS、关联库件均经过产物检查。 +- 当前快照为 DxD;另行记录数据库快照名称,不切换默认原理图。 +- 导出保留 Part Label、Part Number 等原始属性及各工具来源,不合并覆盖字段。 +- 再次使用 `--retry --yes`,耗时 14.063 秒,22 项成功产物经输入、工具和输出摘要核对后全部复用。 +- 14 个工程副本文件逐字节摘要未变化;各工程记录中的原始数据库和中央库前后摘要一致。 +- 664 个发行包文件与 package-manifest.json 的摘要一致。仅显式启动导出程序和自有 helper,不启动 Designer。 + +机器可读证据: + +`F:\MentorExport-dev\build\release-acceptance-20261106-144501\acceptance.json` + +完整实际结果与报告: + +`F:\MentorExport-dev\build\release-acceptance-20261106-144501\导出结果\批次_20261106_144509_6fdd91\导出汇总.html` + +验证脚本为 `packaging/accept_portable.py`;输入引用本机研究工程副本,重复验收会建立新的时间戳目录,保留旧证据。 + +## 兼容范围 + +已验证 EE7.9.5;其他版本能参与环境发现,但原生库读取要求已验证 DLL 指纹。多根配置暂明确报告不支持。装配变体、完整制造几何、字体、多 gate/slot 和可交换脚映射未完整核验。导出成功不等于 ERC 或换料校验通过,也不承诺厂商所有内部字段均可导出。 + +便携包启动问题已在真实入口验收中修正:发布 CMD 使用 CRLF 换行,避免 chcp 65001 后 LF 文件被 CMD 错读。失败的早期验收记录保留,最终结果以以上 passed 记录为准。 diff --git a/export.py b/export.py new file mode 100644 index 0000000..35aaa8a --- /dev/null +++ b/export.py @@ -0,0 +1,16 @@ +"""Portable script bootstrap; always resolves dependencies from its own folder.""" +from pathlib import Path +import os +import sys + +ROOT = Path(__file__).resolve().parent +sys.path.insert(0, str(ROOT)) +_dll_handles = [] +for folder in (ROOT / "runtime/Lib/site-packages/pywin32_system32", + ROOT / "runtime/Lib/site-packages/win32"): + if folder.is_dir() and hasattr(os, "add_dll_directory"): + _dll_handles.append(os.add_dll_directory(str(folder))) + +if __name__ == "__main__": + from mentorexport.cli import main + sys.exit(main()) diff --git a/helpers/build_native.cmd b/helpers/build_native.cmd new file mode 100644 index 0000000..5c92d13 --- /dev/null +++ b/helpers/build_native.cmd @@ -0,0 +1,6 @@ +@echo off +setlocal +call "C:\Program Files (x86)\Microsoft Visual Studio\2022\BuildTools\VC\Auxiliary\Build\vcvars32.bat" >nul +if errorlevel 1 exit /b %errorlevel% +cl /std:c++17 /nologo /W4 /EHsc /O2 /MT "%~dp0native_read.cpp" /Fe"%~dp0native_read.exe" /Fo"%TEMP%\mentorexport-native.obj" +exit /b %errorlevel% diff --git a/helpers/constraints_read.vbs b/helpers/constraints_read.vbs new file mode 100644 index 0000000..a208298 --- /dev/null +++ b/helpers/constraints_read.vbs @@ -0,0 +1,91 @@ +Option Explicit +Dim db, initResult, sheet, obj, cons, fso, output, total, seen, column, definition +Set fso = CreateObject("Scripting.FileSystemObject") +Set output = fso.CreateTextFile(WScript.Arguments(1), True, True) +Set db = CreateObject("CMS.CeObjectDefsICDB") +initResult = db.InitFromProjectFile(WScript.Arguments(2), "r", WScript.Arguments(0), WScript.Arguments(3), WScript.Arguments(4), "DxDesigner") +output.WriteLine "{""kind"":""initialization"",""result"":" & V(initResult) & ",""read_only"":" & V(db.ReadOnly) & ",""project"":" & Q(db.PrjFile) & "}" +If Not initResult Or LCase(db.PrjFile) <> LCase(WScript.Arguments(0)) Then + output.Close + WScript.Quit 3 +End If +total = 0 +Set seen = CreateObject("Scripting.Dictionary") +db.LoadAllDeferredPages +For Each sheet In db.Sheets + output.WriteLine "{""kind"":""sheet"",""name"":" & Q(sheet.Name) & "}" + For Each column In sheet.Columns + Set definition = column.ConstraintDef + output.WriteLine "{""kind"":""definition"",""sheet"":" & Q(sheet.Name) & ",""name"":" & Q(definition.Name) & ",""title"":" & Q(definition.Title) & ",""description"":" & Q(definition.Description) & ",""data_type"":" & V(definition.DataType) & ",""unit_type"":" & V(definition.UnitType) & ",""unit"":" & V(definition.Unit) & ",""display_unit"":" & V(definition.DisplayUnit) & ",""default"":" & V(definition.Default) & "}" + Next + For Each obj In sheet.Objects + DumpObject sheet.Name, obj + Next +Next +output.WriteLine "{""kind"":""complete"",""count"":" & CStr(total) & ",""objects"":" & CStr(seen.Count) & "}" +output.Close +Set db = Nothing +WScript.Echo "Constraints read: " & CStr(total) + +Sub DumpObject(sheetName, current) + Dim key, constraint, child, children, actual, defaultValue, overridden, resolvedDefault, errorText, unitValue, def + key = sheetName & vbTab & current.Level & vbTab & CStr(current.AthenaId) & vbTab & current.Name + If seen.Exists(key) Then Exit Sub + seen.Add key, True + If seen.Count > 100000 Then WScript.Quit 4 + For Each constraint In current.Constraints + actual = "" : defaultValue = "" : overridden = "" : resolvedDefault = "" : errorText = "" + unitValue = "" + On Error Resume Next + actual = constraint.Value + If Err.Number <> 0 Then errorText = errorText & "Value: " & Err.Description & "; " : Err.Clear + defaultValue = constraint.DefaultValue + If Err.Number <> 0 Then errorText = errorText & "DefaultValue: " & Err.Description & "; " : Err.Clear + overridden = constraint.IsOverridden + If Err.Number <> 0 Then errorText = errorText & "IsOverridden: " & Err.Description & "; " : Err.Clear + resolvedDefault = current.IsResolvedDefaultValue(constraint.Name, CStr(actual)) + If Err.Number <> 0 Then errorText = errorText & "IsResolvedDefaultValue: " & Err.Description & "; " : Err.Clear + Set def = constraint.ConstraintDef + unitValue = constraint.GetStringValue(def.Unit) + If Err.Number <> 0 Then errorText = errorText & "GetStringValue: " & Err.Description & "; " : Err.Clear + On Error GoTo 0 + output.WriteLine "{""kind"":""constraint"",""sheet"":" & Q(sheetName) & ",""object"":" & Q(current.Name) & ",""level"":" & Q(current.Level) & ",""athena_id"":" & Q(current.AthenaId) & ",""name"":" & Q(constraint.Name) & ",""value"":" & V(actual) & ",""default_value"":" & V(defaultValue) & ",""is_overridden"":" & V(overridden) & ",""equals_resolved_default"":" & V(resolvedDefault) & ",""value_in_definition_unit"":" & Q(unitValue) & ",""unit"":" & V(def.Unit) & ",""unit_type"":" & V(def.UnitType) & ",""error"":" & Q(errorText) & "}" + total = total + 1 + Next + Set children = current.GetChildObjects + If Not children Is Nothing Then + For Each child In children + DumpObject sheetName, child + Next + End If + Set child = Nothing + Set children = Nothing +End Sub + +Function Q(value) + Dim s + If IsNull(value) Or IsEmpty(value) Then + s = "" + Else + s = CStr(value) + End If + s = Replace(s, "\", "\\") + s = Replace(s, Chr(34), "\" & Chr(34)) + s = Replace(s, vbCr, "\r") + s = Replace(s, vbLf, "\n") + s = Replace(s, vbTab, "\t") + Q = Chr(34) & s & Chr(34) +End Function + +Function V(value) + Select Case VarType(value) + Case 0, 1 + V = "null" + Case 11 + V = LCase(CStr(value)) + Case 2, 3, 4, 5, 6, 14, 17 + V = Replace(CStr(value), ",", ".") + Case Else + V = Q(value) + End Select +End Function diff --git a/helpers/native_read.cpp b/helpers/native_read.cpp new file mode 100644 index 0000000..8edf8fe --- /dev/null +++ b/helpers/native_read.cpp @@ -0,0 +1,216 @@ +#include +#include +#include +#include +#include +#include +#include +#pragma comment(lib, "bcrypt.lib") +// Disposable research client for the locally verified EE7.9.5 x86 PartsDB40 ABI. +// Query a copied PDB. No CAD process or private replacement address is invoked. +static_assert(sizeof(void *) == 4, "This research ABI requires an x86 build."); +struct ObjectGuard { + void *value; + ULONG(__stdcall *release)(void *); + ~ObjectGuard() { + if (value) + release(value); + } +}; +struct ModuleGuard { + HMODULE value; + ~ModuleGuard() { + if (value) + FreeLibrary(value); + } +}; +static void str(const char *p) { + std::string utf8; + if (p && *p) { + int count = + MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, p, -1, nullptr, 0); + if (!count) + throw std::runtime_error( + "Metadata encoding is invalid for the native ANSI code page"); + std::vector wide(count); + if (!MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, p, -1, wide.data(), + count)) + throw std::runtime_error("ANSI decoding failed"); + int size = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, wide.data(), + count - 1, nullptr, 0, nullptr, nullptr); + if (!size) + throw std::runtime_error("UTF-8 conversion failed"); + utf8.resize(size); + if (!WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, wide.data(), + count - 1, utf8.data(), size, nullptr, nullptr)) + throw std::runtime_error("UTF-8 conversion failed"); + } + putchar('"'); + for (unsigned char c : utf8) { + if (c == '"' || c == '\\') + printf("\\%c", c); + else if (c < 32) + printf("\\u%04x", c); + else + putchar(c); + } + putchar('"'); +} +template T proc(HMODULE h, const char *name) { + auto p = GetProcAddress(h, name); + if (!p) + throw std::runtime_error(name); + return reinterpret_cast(p); +} +using ReadString = HRESULT(__stdcall *)(void *, int, const char **); +using ReadInt = HRESULT(__stdcall *)(void *, int, int *); +using ReadList = HRESULT(__stdcall *)(void *, int, const int **, int *); +using ReadPair = HRESULT(__stdcall *)(void *, int, int *, int *); +using ReadPoint = HRESULT(__stdcall *)(void *, int, const int **); + +static void check(HRESULT hr) { + if (FAILED(hr)) throw std::runtime_error("Native getter failed"); +} +static void string_field(HMODULE module, void *db, int id, const char *symbol, + const char *field) { + const char *value = nullptr; + HRESULT hr = proc(module, symbol)(db, id, &value); + putchar(','); str(field); printf(":{\"hr\":%ld,\"value\":", hr); + if (SUCCEEDED(hr)) str(value); else printf("null"); + putchar('}'); +} +static std::vector ids(HMODULE module, void *db, int id, const char *symbol) { + const int *data = nullptr; int count = 0; + check(proc(module, symbol)(db, id, &data, &count)); + if (count < 0 || count > 100000 || (count && !data)) + throw std::runtime_error("Invalid native list"); + return count ? std::vector(data, data + count) : std::vector(); +} +static bool verified_dll(const std::string &path, const char *expected) { + FILE *file = nullptr; + if (fopen_s(&file, path.c_str(), "rb") || !file) return false; + BCRYPT_ALG_HANDLE algorithm = nullptr; + BCRYPT_HASH_HANDLE hash = nullptr; + unsigned char result[32], block[65536]; + bool ok = BCryptOpenAlgorithmProvider(&algorithm, BCRYPT_SHA256_ALGORITHM, nullptr, 0) == 0; + if (ok) ok = BCryptCreateHash(algorithm, &hash, nullptr, 0, nullptr, 0, 0) == 0; + size_t count; + while (ok && (count = fread(block, 1, sizeof(block), file)) != 0) + ok = BCryptHashData(hash, block, static_cast(count), 0) == 0; + if (ferror(file)) ok = false; + if (ok) ok = BCryptFinishHash(hash, result, sizeof(result), 0) == 0; + fclose(file); + if (hash) BCryptDestroyHash(hash); + if (algorithm) BCryptCloseAlgorithmProvider(algorithm, 0); + if (!ok) return false; + char hex[65]; + for (unsigned i = 0; i < 32; ++i) sprintf_s(hex + i * 2, 65 - i * 2, "%02x", result[i]); + return strcmp(hex, expected) == 0; +} +int main(int argc, char **argv) { + if (argc != 4) return 64; + bool cell = !strcmp(argv[1], "cell"); + if (!cell && strcmp(argv[1], "parts")) return 64; + SetDllDirectoryA(argv[2]); + std::string filename = std::string(argv[2]) + (cell ? "\\CellDB40.dll" : "\\PartsDB40.dll"); + if (!verified_dll(filename, cell ? "e3fb93a0b5e5d2d027a82f71d1ee13d497598f709ced54c9145a781af6a54d26" + : "f24d44eaa13f28550317711df6a6241e227ae56805baa73c8f3020bde513ad0d")) { + fprintf(stderr, "Unverified DLL ABI: SHA256 does not match the validated EE7.9.5 library.\n"); + return 65; + } + HMODULE h = LoadLibraryA(filename.c_str()); ModuleGuard module{h}; + if (!h) return 2; + try { + using Factory = HRESULT(__cdecl *)(void **); + using Loader = HRESULT(__stdcall *)(void *, const char *, int); + using GetEnum = HRESULT(__stdcall *)(void *, void **); + using Next = HRESULT(__stdcall *)(void *, ULONG, int *, ULONG *); + using Release = ULONG(__stdcall *)(void *); + const char *klass = cell ? "CellDB" : "PartsDB"; + auto decorated = [klass](const char *method, const char *suffix) { + return std::string("?") + method + "@" + klass + "@@" + suffix; + }; + auto symbol = [&](const char *method, const char *suffix) { + return GetProcAddress(h, decorated(method, suffix).c_str()); + }; + auto release = reinterpret_cast(symbol("Release", "UAGKXZ")); + auto load = reinterpret_cast(symbol("Loader", "UAGJPBDH@Z")); + if (!release || !load) throw std::runtime_error("Missing required exports"); + void *db = nullptr; + check(proc(h, cell ? "GetCellDBPtr" : "GetPartsDBPtr")(&db)); + ObjectGuard db_guard{db, release}; if (!db) return 3; + check(load(db, argv[3], 0)); + auto enumerate = reinterpret_cast(symbol(cell ? "GetCellEnum" : "GetPartEnum", "UAGJPAPAUIEnumInt@@@Z")); + auto next = proc(h, cell ? "?Next@EnumCellDBCell@@UAGJKPAHPAK@Z" : "?Next@EnumPartsDBPart@@UAGJKPAHPAK@Z"); + auto release_enum = proc(h, cell ? "?Release@EnumCellDBCell@@UAGKXZ" : "?Release@EnumPartsDBPart@@UAGKXZ"); + if (!enumerate) throw std::runtime_error("Missing enumerator export"); + void *e = nullptr; check(enumerate(db, &e)); ObjectGuard enum_guard{e, release_enum}; + auto name = reinterpret_cast(symbol(cell ? "GetName" : "GetPartNumber", "UAGJHPAPBD@Z")); + if (!e || !name) return 4; + printf("{\"mode\":\"%s\"", argv[1]); + if (cell) { + using BaseUnit = HRESULT(__stdcall *)(void *, int *); + int unit = -1; + HRESULT unit_hr = proc(h, "?GetCellDBBaseUnit@CellDB@@UAGJPAH@Z")(db, &unit); + printf(",\"base_unit_hr\":%ld,\"base_unit_code\":%d", unit_hr, unit); + } + printf(",\"records\":["); + unsigned count = 0; + for (;;) { + int id = -1; ULONG fetched = 0; HRESULT hr = next(e, 1, &id, &fetched); + check(hr); if (!fetched) break; + if (++count > 100000) return 6; + const char *n = nullptr; check(name(db, id, &n)); + if (count > 1) putchar(','); printf("{\"id\":%d,\"name\":", id); str(n); + if (cell) { + string_field(h, db, id, "?GetDescription@CellDB@@UAGJHPAPBD@Z", "description"); + auto pins = ids(h, db, id, "?GetPins@CellDB@@UAGJHPAPBHPAH@Z"); + printf(",\"pins\":["); bool first = true; + for (int pin : pins) { + if (!first) putchar(','); first = false; printf("{\"id\":%d", pin); + string_field(h, db, pin, "?GetPinName@CellDB@@UAGJHPAPBD@Z", "name"); + string_field(h, db, pin, "?GetPinPadstackName@CellDB@@UAGJHPAPBD@Z", "padstack"); + const int *point = nullptr; int rotation = 0; + HRESULT hp = proc(h, "?GetPinLocation@CellDB@@UAGJHPAPBH@Z")(db, pin, &point); + HRESULT rotation_hr = proc(h, "?GetPinRotation@CellDB@@UAGJHPAH@Z")(db, pin, &rotation); + printf(",\"location_hr\":%ld,\"rotation_hr\":%ld,\"rotation_raw\":%d,\"xy_raw\":", hp, rotation_hr, rotation); + if (SUCCEEDED(hp) && point) printf("[%d,%d]", point[0], point[1]); else printf("null"); + putchar('}'); + } + putchar(']'); + } else { + string_field(h, db, id, "?GetPartName@PartsDB@@UAGJHPAPBD@Z", "part_name"); + string_field(h, db, id, "?GetPartLabel@PartsDB@@UAGJHPAPBD@Z", "part_label"); + string_field(h, db, id, "?GetTopCellName@PartsDB@@UAGJHPAPBD@Z", "top_cell_name"); + string_field(h, db, id, "?GetBottomCellName@PartsDB@@UAGJHPAPBD@Z", "bottom_cell_name"); + printf(",\"properties\":["); bool first = true; + for (int property : ids(h, db, id, "?GetPartProperties@PartsDB@@UAGJHPAPBHPAH@Z")) { + int registry = -1, value = -1; + check(proc(h, "?GetProperty@PartsDB@@UAGJHPAH0@Z")(db, property, ®istry, &value)); + if (!first) putchar(','); first = false; + printf("{\"property_id\":%d,\"registry_id\":%d,\"value_id\":%d", property, registry, value); + string_field(h, db, registry, "?GetPrpName@PartsDB@@UAGJHPAPBD@Z", "name"); + string_field(h, db, value, "?GetValueText@PartsDB@@UAGJHPAPBD@Z", "text"); putchar('}'); + } + printf("],\"symbols\":["); first = true; + for (int sym : ids(h, db, id, "?GetSymDfnList@PartsDB@@UAGJHPAPBHPAH@Z")) { + if (!first) putchar(','); first = false; printf("{\"id\":%d", sym); + string_field(h, db, sym, "?GetSymDfnName@PartsDB@@UAGJHPAPBD@Z", "name"); + printf(",\"pins\":["); bool first_pin = true; + for (int pin : ids(h, db, sym, "?GetSymPinList@PartsDB@@UAGJHPAPBHPAH@Z")) { + if (!first_pin) putchar(','); first_pin = false; printf("{\"id\":%d", pin); + string_field(h, db, pin, "?GetSymPinName@PartsDB@@UAGJHPAPBD@Z", "name"); + int ordinal = -1; HRESULT ordinal_hr = proc(h, "?GetSymPinOrdinal@PartsDB@@UAGJHPAH@Z")(db, pin, &ordinal); + printf(",\"ordinal_hr\":%ld,\"ordinal\":%d}", ordinal_hr, ordinal); + } + printf("]}"); + } + printf("]"); + } + putchar('}'); + } + printf("],\"count\":%u}\n", count); return 0; + } catch (const std::exception &e) { + fprintf(stderr, "read failed: %s\n", e.what()); return 9; + } +} diff --git a/helpers/native_read.exe b/helpers/native_read.exe new file mode 100644 index 0000000000000000000000000000000000000000..93317c321d9a5e87bb346cb0a809d77021365167 GIT binary patch literal 142336 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 z%0A}9+xFghVnHV7{_bD1b&&;nuPgbk01u~ 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 VV601-SbvHPBr*Sf{@>@o{{qpHu=W4| literal 0 HcmV?d00001 diff --git a/mentorexport/__init__.py b/mentorexport/__init__.py new file mode 100644 index 0000000..95162b5 --- /dev/null +++ b/mentorexport/__init__.py @@ -0,0 +1,2 @@ +"""Portable Mentor saved-schematic exports.""" +__version__ = "0.1.0" diff --git a/mentorexport/_desktop.py b/mentorexport/_desktop.py new file mode 100644 index 0000000..2922fca --- /dev/null +++ b/mentorexport/_desktop.py @@ -0,0 +1,698 @@ +"""Owned Windows private-desktop process boundary for CAD and research workers. + +This module deliberately contains no CAD automation. It only creates a +desktop, starts a process on that desktop, and closes resources it owns. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from contextlib import ExitStack +from copy import deepcopy +import ctypes +from ctypes import wintypes +import math +import os +from pathlib import Path +import subprocess +import sys +import time +from threading import get_native_id +from typing import Mapping, Sequence + +from ._errors import TaskCenterError + + +DESKTOP_RELEASE_TIMEOUT_SECONDS = 5.0 +DESCENDANT_EXIT_GRACE_SECONDS = 2.0 + + +def _native_handle(handle): + try: + return int(handle) if handle is not None else None + except (TypeError, ValueError): + return None + + +def _resource_event(operation, handle, success, error=None): + return {'operation': operation, 'handle': _native_handle(handle), 'success': success, + 'pid': os.getpid(), 'thread_id': get_native_id(), 'time_ns': time.time_ns(), + 'error': str(error) if error is not None else None} + + +@dataclass(frozen=True, slots=True) +class StartupInfo: + lpDesktop: str + + +def build_startup_info(desktop_name: str) -> StartupInfo: + if not desktop_name or "\\" in desktop_name or "\x00" in desktop_name: + raise TaskCenterError("private_desktop", "invalid private desktop name") + return StartupInfo(lpDesktop=f"winsta0\\{desktop_name}") + + +class _Win32Api: + def __init__(self) -> None: + try: + import win32api, win32con, win32event, win32job, win32process, win32service + except ImportError as error: + raise TaskCenterError("private_desktop", "pywin32 is required for private desktop supervision") from error + self.con, self.job, self.process, self.service = win32con, win32job, win32process, win32service + self.event = win32event + self.open_process = win32api.OpenProcess + self._pending_cleanup = [] + + def create_desktop(self, name: str): + return self.service.CreateDesktop(name, 0, self.con.GENERIC_ALL, None) + + def confirm_desktop_released(self, name: str): + started = time.monotonic() + # USER references can outlive the owned processes briefly. Allow a + # bounded grace period, without delaying the usual immediate release + # or accepting a desktop that still has a persistent external owner. + budget = DESKTOP_RELEASE_TIMEOUT_SECONDS + deadline = started + budget + self.desktop_release_check = {'desktop': name, 'released': None, + 'elapsed_seconds': 0.0, 'budget_seconds': budget} + while True: + # EnumDesktops avoids reopening/closing a handle which Windows may + # share with another desktop handle held by this process. + names = self.service.GetProcessWindowStation().EnumDesktops() + present = name.casefold() in {value.casefold() for value in names} + self.desktop_release_check = {'desktop': name, 'released': not present, + 'elapsed_seconds': time.monotonic() - started, 'budget_seconds': budget, + 'caller_pid': os.getpid(), 'caller_thread_id': get_native_id()} + if not present: + return + if time.monotonic() >= deadline: + try: + from ._identity import current_desktop_name + self.desktop_release_check['caller_desktop'] = current_desktop_name() + except Exception as error: + self.desktop_release_check['caller_desktop_error'] = str(error) + try: + self.desktop_release_check['remaining_windows'] = self._desktop_windows(name) + except Exception as error: + self.desktop_release_check['window_query_error'] = str(error) + raise TaskCenterError('private_desktop_cleanup', 'owned private desktop still exists after cleanup') + time.sleep(min(0.05, max(0.0, deadline - time.monotonic()))) + + def _desktop_windows(self, name): + """Diagnose residue without switching desktops or terminating foreign owners.""" + import win32gui + + desktop = self.service.OpenDesktop(name, 0, False, 1) # DESKTOP_READOBJECTS + windows = [] + try: + user = ctypes.WinDLL('user32', use_last_error=True) + callback_type = ctypes.WINFUNCTYPE(wintypes.BOOL, wintypes.HWND, wintypes.LPARAM) + enumerate_windows = user.EnumDesktopWindows + enumerate_windows.argtypes = [wintypes.HANDLE, callback_type, wintypes.LPARAM] + enumerate_windows.restype = wintypes.BOOL + handles = [] + callback = callback_type(lambda handle, _: handles.append(handle) or True) + # An empty desktop can return FALSE with no last error. Our + # callback always continues, so only a nonzero error is a failure. + ctypes.set_last_error(0) + if not enumerate_windows(int(desktop), callback, 0) and ctypes.get_last_error(): + raise ctypes.WinError(ctypes.get_last_error()) + for handle in handles: + thread, pid = self.process.GetWindowThreadProcessId(handle) + windows.append({'hwnd': int(handle), 'pid': pid, 'thread_id': thread, + 'class': win32gui.GetClassName(handle)}) + finally: + desktop.CloseDesktop() + return windows + + def create_process(self, command: Sequence[str], desktop: str, cwd: Path | None, env: Mapping[str, str] | None, + *, stdout=None, stderr=None): + # Windows venv python.exe redirects to a second process. Launch the + # interpreter directly with its venv identity, so the handle we own is + # also the process that admits the request and creates desktop windows. + if (not getattr(sys, 'frozen', False) and sys.prefix != sys.base_prefix + and os.path.normcase(os.path.abspath(str(command[0]))) == os.path.normcase(sys.executable) + and getattr(sys, '_base_executable', None)): + command = (sys._base_executable, *command[1:]) + env = dict(os.environ if env is None else env) + env['__PYVENV_LAUNCHER__'] = sys.executable + startup = self.process.STARTUPINFO() + startup.lpDesktop = desktop + flags = self.con.CREATE_NO_WINDOW | self.con.CREATE_SUSPENDED + job = self.job.CreateJobObject(None, "") + process = None + try: + info = self.job.QueryInformationJobObject(job, self.job.JobObjectExtendedLimitInformation) + info["BasicLimitInformation"]["LimitFlags"] |= self.job.JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE + self.job.SetInformationJobObject(job, self.job.JobObjectExtendedLimitInformation, info) + streams = (None, None) + if stdout is not None or stderr is not None: + (handle, thread, pid, _), streams = _create_redirected_process(command, desktop, cwd, env, flags, stdout, stderr) + else: + handle, thread, pid, _ = self.process.CreateProcess( + str(command[0]), subprocess.list2cmdline([str(item) for item in command]), + None, None, False, flags, env, str(cwd) if cwd else None, startup, + ) + process = _Win32Process(self.process, self.job, self.event, handle, job, int(pid), command, + open_process=getattr(self, 'open_process', None)) + process.stdout, process.stderr = streams + process.thread = thread + self.job.AssignProcessToJobObject(job, handle) + process.job_assigned = True + if not self.job.IsProcessInJob(handle, job): + raise TaskCenterError('private_desktop', 'Owned process Job membership was not confirmed') + process.cleanup_record['job_membership_verified'] = True + self.process.ResumeThread(thread) + thread.Close() + process.thread = None + except Exception as error: + try: + if process is not None: + # Assignment can fail before the job owns this suspended process. + process.close() + else: + job.Close() + except Exception as cleanup_error: + pending = getattr(self, '_pending_cleanup', None) + if pending is None: + self._pending_cleanup = pending = [] + pending.append(process if process is not None else job) + raise TaskCenterError('private_desktop', f'launch failed: {error}; cleanup failed: {cleanup_error}') from error + raise + return process + + def close_pending(self): + errors, remaining = [], [] + for resource in getattr(self, '_pending_cleanup', []): + try: + resource.close() if isinstance(resource, _Win32Process) else resource.Close() + except Exception as error: + errors.append(error) + remaining.append(resource) + self._pending_cleanup = remaining + _raise_cleanup_errors(errors) + + +def _raise_cleanup_errors(errors): + if errors: + raise TaskCenterError('private_desktop_cleanup', '; '.join(str(error) for error in errors)) + + +def _stop_and_wait(process): + errors = [] + running = True + try: + running = process.poll() is None + except Exception as error: + errors.append(error) + if running: + try: + if isinstance(process, _Win32Process): + process.terminate(reason='root_process_active') + else: + process.terminate() + except Exception as error: + errors.append(error) + try: + process.wait(timeout=5.0) + except Exception as error: + errors.append(error) + return errors + + +def _create_redirected_process(command, desktop, cwd, env, flags, stdout, stderr): + """Use an explicit inheritance list; never inherit unrelated parent handles.""" + import msvcrt + import pywintypes + + class NativeStartup(ctypes.Structure): + _fields_ = [ + ('cb', wintypes.DWORD), ('lpReserved', wintypes.LPWSTR), + ('lpDesktop', wintypes.LPWSTR), ('lpTitle', wintypes.LPWSTR), + ('dwX', wintypes.DWORD), ('dwY', wintypes.DWORD), + ('dwXSize', wintypes.DWORD), ('dwYSize', wintypes.DWORD), + ('dwXCountChars', wintypes.DWORD), ('dwYCountChars', wintypes.DWORD), + ('dwFillAttribute', wintypes.DWORD), ('dwFlags', wintypes.DWORD), + ('wShowWindow', wintypes.WORD), ('cbReserved2', wintypes.WORD), + ('lpReserved2', ctypes.POINTER(ctypes.c_byte)), + ('hStdInput', wintypes.HANDLE), ('hStdOutput', wintypes.HANDLE), ('hStdError', wintypes.HANDLE), + ] + class ExtendedStartup(ctypes.Structure): + _fields_ = [('StartupInfo', NativeStartup), ('lpAttributeList', ctypes.c_void_p)] + class ProcessInformation(ctypes.Structure): + _fields_ = [('hProcess', wintypes.HANDLE), ('hThread', wintypes.HANDLE), + ('dwProcessId', wintypes.DWORD), ('dwThreadId', wintypes.DWORD)] + + kernel = ctypes.WinDLL('kernel32', use_last_error=True) + initialize = kernel.InitializeProcThreadAttributeList + initialize.argtypes = [ctypes.c_void_p, wintypes.DWORD, wintypes.DWORD, ctypes.POINTER(ctypes.c_size_t)] + initialize.restype = wintypes.BOOL + update = kernel.UpdateProcThreadAttribute + update.argtypes = [ctypes.c_void_p, wintypes.DWORD, ctypes.c_size_t, ctypes.c_void_p, + ctypes.c_size_t, ctypes.c_void_p, ctypes.c_void_p] + update.restype = wintypes.BOOL + delete = kernel.DeleteProcThreadAttributeList + delete.argtypes = [ctypes.c_void_p] + delete.restype = None + create = kernel.CreateProcessW + create.argtypes = [wintypes.LPCWSTR, wintypes.LPWSTR, ctypes.c_void_p, ctypes.c_void_p, + wintypes.BOOL, wintypes.DWORD, ctypes.c_void_p, wintypes.LPCWSTR, + ctypes.POINTER(ExtendedStartup), ctypes.POINTER(ProcessInformation)] + create.restype = wintypes.BOOL + readers = [None, None] + try: + with ExitStack() as children: + def output_handle(target, channel): + if target == subprocess.PIPE: + read_fd, write_fd = os.pipe() + readers[channel] = os.fdopen(read_fd, 'rb') + writer = children.enter_context(os.fdopen(write_fd, 'wb')) + elif target is None or target == subprocess.DEVNULL: + writer = children.enter_context(open(os.devnull, 'wb')) + else: + writer = children.enter_context(os.fdopen(os.dup(target.fileno()), 'wb')) + handle = msvcrt.get_osfhandle(writer.fileno()) + os.set_handle_inheritable(handle, True) + return handle + + stdin_file = children.enter_context(open(os.devnull, 'rb')) + stdin_handle = msvcrt.get_osfhandle(stdin_file.fileno()) + os.set_handle_inheritable(stdin_handle, True) + stdout_handle = output_handle(stdout, 0) + stderr_handle = stdout_handle if stderr == subprocess.STDOUT else output_handle(stderr, 1) + handles = list(dict.fromkeys((stdin_handle, stdout_handle, stderr_handle))) + inherited = (wintypes.HANDLE * len(handles))(*handles) + size = ctypes.c_size_t() + initialize(None, 1, 0, ctypes.byref(size)) + attributes = ctypes.create_string_buffer(size.value) + if not initialize(attributes, 1, 0, ctypes.byref(size)): + raise ctypes.WinError(ctypes.get_last_error()) + try: + if not update(attributes, 0, 0x20002, inherited, ctypes.sizeof(inherited), None, None): + raise ctypes.WinError(ctypes.get_last_error()) + startup = ExtendedStartup() + startup.StartupInfo.cb = ctypes.sizeof(startup) + startup.StartupInfo.lpDesktop = desktop + startup.StartupInfo.dwFlags = 0x100 # STARTF_USESTDHANDLES + startup.StartupInfo.hStdInput = stdin_handle + startup.StartupInfo.hStdOutput = stdout_handle + startup.StartupInfo.hStdError = stderr_handle + startup.lpAttributeList = ctypes.addressof(attributes) + information = ProcessInformation() + environment = None if env is None else ctypes.create_unicode_buffer( + '\0'.join(f'{key}={value}' for key, value in sorted(env.items(), key=lambda item: item[0].upper())) + '\0\0') + command_line = ctypes.create_unicode_buffer(subprocess.list2cmdline([str(item) for item in command])) + if not create(str(command[0]), command_line, None, None, True, + flags | 0x80000 | 0x400, environment, str(cwd) if cwd else None, + ctypes.byref(startup), ctypes.byref(information)): + raise ctypes.WinError(ctypes.get_last_error()) + result = (pywintypes.HANDLE(information.hProcess), pywintypes.HANDLE(information.hThread), + information.dwProcessId, information.dwThreadId) + finally: + delete(attributes) + return result, readers + except BaseException: + for reader in readers: + if reader is not None: + reader.close() + raise + + +class _Win32Process: + def __init__(self, process_api, job_api, event_api, handle, job, pid: int, args, *, open_process=None): + self._process_api, self._job_api = process_api, job_api + self._event_api = event_api + self._open_process = open_process + self._descendant_handles = [] + self._descendant_pids = set() + self.handle, self.job, self.pid = handle, job, pid + self.args = args + self.thread = None + self.job_assigned = False + self.returncode = None + self.stdout = self.stderr = None + self.cleanup_record = {'pid': self.pid, 'forced_termination': False, + 'forced_root_termination': False, 'forced_descendant_pids': [], + 'termination_reason': None} + + def poll(self): + if self.returncode is not None or self.handle is None: + return self.returncode + status = self._event_api.WaitForSingleObject(self.handle, 0) + if status == 258: # WAIT_TIMEOUT: 259 is also a valid *completed* exit code. + return None + if status != 0: + raise OSError(f'process wait failed with status {status}') + self.returncode = self._process_api.GetExitCodeProcess(self.handle) + return self.returncode + + def tree_exited(self): + if self.poll() is None: + return False + if self.job is not None and self.job_assigned: + active = self._job_api.QueryInformationJobObject( + self.job, self._job_api.JobObjectBasicAccountingInformation)['ActiveProcesses'] + if active: + return False + return all(self._event_api.WaitForSingleObject(handle, 0) == 0 + for handle in self._descendant_handles) + + def wait(self, timeout=None): + if self.returncode is not None: + return self.returncode + if self.handle is None: + raise OSError('owned process handle is closed before exit was confirmed') + milliseconds = 0xFFFFFFFF if timeout is None else min(max(math.ceil(timeout * 1000), 0), 0xFFFFFFFE) + status = self._event_api.WaitForSingleObject(self.handle, milliseconds) + if status == 258: + raise subprocess.TimeoutExpired(self.args, timeout) + if status != 0: + raise OSError(f'process wait failed with status {status}') + self.returncode = self._process_api.GetExitCodeProcess(self.handle) + return self.returncode + + def terminate(self, *, reason='explicit_termination'): + if self.handle is None: + return + errors = [] + root_active = True + try: + root_active = self.poll() is None + except Exception as error: + errors.append(error) + self.cleanup_record.setdefault('root_exit_before_cleanup', not root_active) + if not self.job_assigned: + self._process_api.TerminateProcess(self.handle, 1) + self._record_termination(reason, root_active, ()) + _raise_cleanup_errors(errors) + return + descendants = set() + try: + # Keep confirmed members of this snapshot even if opening a later + # member fails; the Job termination below still includes them. + self._remember_descendants(active=descendants) + except Exception as error: + errors.append(error) + try: + self._job_api.TerminateJobObject(self.job, 1) + self._record_termination(reason, root_active, descendants) + except Exception: + self._process_api.TerminateProcess(self.handle, 1) + self._record_termination(reason, root_active, ()) + _raise_cleanup_errors(errors) + + kill = terminate + + def _record_termination(self, reason, root_active, descendants): + self.cleanup_record.update(forced_termination=True, + forced_root_termination=self.cleanup_record['forced_root_termination'] or root_active, + forced_descendant_pids=sorted(set(self.cleanup_record['forced_descendant_pids']) | set(descendants)), + termination_reason=self.cleanup_record['termination_reason'] or reason) + + def _remember_descendants(self, *, active=None): + if active is None: + active = set() + if self._open_process is None or self.job is None: + return active + for pid in self._job_api.QueryInformationJobObject(self.job, self._job_api.JobObjectBasicProcessIdList): + if pid == self.pid: + continue + if pid in self._descendant_pids: + active.add(pid) + continue + try: + self._descendant_handles.append(self._open_process(0x100000, False, pid)) + self._descendant_pids.add(pid) + active.add(pid) + except Exception as error: + # pywintypes.error is not an OSError. A child that exited + # between the job snapshot and OpenProcess reports error 87. + code = getattr(error, 'winerror', None) + if code is None and error.args: + code = error.args[0] + if code != 87: + raise + return active + + def close(self): + errors = [] + job_empty = not self.job_assigned or self.job is None + if self.handle is not None: + if 'root_exit_before_cleanup' not in self.cleanup_record: + try: + self.cleanup_record['root_exit_before_cleanup'] = self.poll() is not None + except Exception as error: + errors.append(error) + errors.extend(_stop_and_wait(self)) + deadline = time.monotonic() + 5.0 + if self.job is not None and self.job_assigned: + try: + grace_started = time.monotonic() + grace_deadline = grace_started + DESCENDANT_EXIT_GRACE_SECONDS + # A completed root may leave children finishing normal shutdown. + # An empty job takes no grace delay; an active root was already + # stopped above and does not receive this normal-exit allowance. + while True: + active = self._job_api.QueryInformationJobObject( + self.job, self._job_api.JobObjectBasicAccountingInformation)['ActiveProcesses'] + self.cleanup_record['job_active_processes'] = active + if not active: + job_empty = True + break + self._remember_descendants() + if (self.cleanup_record.get('root_exit_before_cleanup') is not True + or self.cleanup_record['forced_termination'] or time.monotonic() >= grace_deadline): + self.terminate(reason='descendant_grace_expired') + break + time.sleep(min(0.01, max(0, grace_deadline - time.monotonic()))) + self.cleanup_record['descendant_grace_seconds'] = time.monotonic() - grace_started + deadline = time.monotonic() + 5.0 + while True: + active = self._job_api.QueryInformationJobObject( + self.job, self._job_api.JobObjectBasicAccountingInformation)['ActiveProcesses'] + self.cleanup_record['job_active_processes'] = active + if not active: + job_empty = True + break + if time.monotonic() >= deadline: + raise TimeoutError('owned job descendants did not exit within 5 seconds') + time.sleep(0.01) + except Exception as error: + errors.append(error) + retained = [] + for descendant in self._descendant_handles: + try: + # Job accounting can reach zero before a terminated process is signaled. + remaining = max(0, math.ceil((deadline - time.monotonic()) * 1000)) + if self._event_api.WaitForSingleObject(descendant, remaining) != 0: + raise TimeoutError('owned job descendant exit was not confirmed within 5 seconds') + except Exception as error: + errors.append(error) + retained.append(descendant) + continue + try: + descendant.Close() + except Exception as error: + errors.append(error) + retained.append(descendant) + self._descendant_handles = retained + for name in ('job', 'thread', 'handle'): + handle = getattr(self, name) + if name in ('job', 'handle') and not job_empty: + # Closing a KILL_ON_JOB_CLOSE job would silently force remaining + # children and discard the capability needed for cleanup retry. + continue + if name == 'handle' and self.returncode is None: + # Keep the only termination/wait capability until cleanup can retry. + continue + if handle is not None: + try: + handle.Close() + setattr(self, name, None) + except Exception as error: + errors.append(error) + for stream in (self.stdout, self.stderr): + if stream is not None: + try: + stream.close() + except Exception as error: + errors.append(error) + self.cleanup_record.update(exit_code=self.returncode, descendant_pids=sorted(self._descendant_pids), + unconfirmed_descendant_handles=len(self._descendant_handles), + process_handle_closed=self.handle is None, job_handle_closed=self.job is None, + errors=[str(error) for error in errors]) + _raise_cleanup_errors(errors) + + +class PrivateDesktop: + """Own a private Windows desktop and processes started on it.""" + + def __init__(self, name: str, *, enabled: bool = False, api=None) -> None: + self.name = name + self.enabled = enabled + self._handle = None + self._processes: list[subprocess.Popen[str]] = [] + self._api = api + self.cleanup_record = None + self._desktop_handle_history = [] + self._process_history = [] + + def __enter__(self) -> "PrivateDesktop": + if not self.enabled: + raise TaskCenterError("private_desktop_opt_in", "private desktop backend requires explicit opt-in") + self._create() + if self._handle is None: + raise TaskCenterError("private_desktop", "private desktop could not be created") + return self + + def __exit__(self, *_exc: object) -> None: + self.close() + + def inspect_dialogs(self, pid): + if self._handle is None or not any(process.pid == pid and process.poll() is None for process in self._processes): + return () + return tuple(window for window in self._api._desktop_windows(self.name) if window['pid'] == pid) + + def _create(self) -> None: + if os.name != "nt" and self._api is None: + return + self._api = self._api or _Win32Api() + try: + self._handle = self._api.create_desktop(self.name) + except Exception as error: + self._desktop_handle_history.append(_resource_event('create', None, False, error)) + raise + self._desktop_handle_history.append(_resource_event('create', self._handle, self._handle is not None)) + + def start_process( + self, + command: Sequence[str], + *, + cwd: Path | None = None, + env: Mapping[str, str] | None = None, + stdout=None, + stderr=None, + ) -> subprocess.Popen[str]: + if not self.enabled or self._handle is None: + raise TaskCenterError("private_desktop", "process launch requires an owned private desktop") + if not command: + raise TaskCenterError("private_desktop", "private desktop command is empty") + if self._api is None: + raise TaskCenterError("private_desktop", "private desktop process API is unavailable") + options = {} if stdout is None and stderr is None else {'stdout': stdout, 'stderr': stderr} + process = self._api.create_process(command, build_startup_info(self.name).lpDesktop, cwd, env, **options) + self._processes.append(process) + self._process_history.append({'pid': getattr(process, 'pid', None), + 'owner_pid': os.getpid(), 'owner_thread_id': get_native_id(), + 'started_time_ns': time.time_ns(), 'process_handle': _native_handle(getattr(process, 'handle', None)), + 'job_handle': _native_handle(getattr(process, 'job', None)), 'forgotten': False}) + return process + + def _remember_process_cleanup(self, process, *, forgotten=False): + for record in reversed(self._process_history): + if record['pid'] == getattr(process, 'pid', None) and not record['forgotten']: + record['cleanup'] = deepcopy(getattr(process, 'cleanup_record', {})) + record['forgotten'] = forgotten + record['observed_time_ns'] = time.time_ns() + break + + def forget_closed_process(self, process): + """Drop a worker only after its owning wrapper confirmed all cleanup.""" + record = getattr(process, 'cleanup_record', {}) + if (record.get('process_handle_closed') is not True + or record.get('job_handle_closed') is not True + or record.get('unconfirmed_descendant_handles', 0) + or record.get('errors') or process.poll() is None): + raise OSError('cannot forget a worker with unconfirmed owned resources') + self._processes = [item for item in self._processes if item is not process] + self._remember_process_cleanup(process, forgotten=True) + + def close(self) -> None: + errors, remaining = [], [] + self.cleanup_record = {'desktop': self.name, 'processes': []} + for process in reversed(self._processes): + process_errors = _stop_and_wait(process) + errors.extend(process_errors) + failed = bool(process_errors) + try: + process.close() + except Exception as error: + errors.append(error) + failed = True + self.cleanup_record['processes'].append(getattr(process, 'cleanup_record', { + 'pid': getattr(process, 'pid', None), 'exit_code': getattr(process, 'returncode', None)})) + self._remember_process_cleanup(process) + if failed: + remaining.append(process) + self._processes = list(reversed(remaining)) + close_pending = getattr(self._api, 'close_pending', None) + if close_pending: + try: + close_pending() + except Exception as error: + errors.append(error) + close_desktop = getattr(self._handle, "CloseDesktop", None) + if close_desktop: + event = _resource_event('close', self._handle, False) + try: + close_desktop() + event['success'] = True + self._handle = None + except Exception as error: + errors.append(error) + event['error'] = str(error) + self._desktop_handle_history.append(event) + confirm = getattr(self._api, 'confirm_desktop_released', None) + if confirm and self._handle is None: + try: + confirm(self.name) + except Exception as error: + errors.append(error) + self.cleanup_record.update(desktop_handle_closed=self._handle is None, + desktop_confirmation=getattr(self._api, 'desktop_release_check', None), + desktop_handle_history=deepcopy(self._desktop_handle_history), + process_history=deepcopy(self._process_history), + diagnostic_scope={'external_handle_holders': 'unknown', + 'thread_desktops': 'unknown unless observed through residual windows; no exhaustive holder scan', + 'empty_windows_prove_no_holders': False}, + errors=[str(error) for error in errors]) + if errors: + self.cleanup_record['owned_resource_diagnostics'] = self._owned_resource_diagnostics() + _raise_cleanup_errors(errors) + + def _owned_resource_diagnostics(self): + """Bounded queries of our handles only; never terminate/query foreign PIDs. + + GetThreadDesktop can introduce borrowed USER references. Do not run a + global thread scan in this long-lived owner while retrying release. + Window observations identify only window-owning threads, not every + thread or an external OpenDesktop handle holder. + """ + resources = [] + for process in self._processes: + item = {'pid': getattr(process, 'pid', None), + 'process_handle': _native_handle(getattr(process, 'handle', None)), + 'job_handle': _native_handle(getattr(process, 'job', None)), + 'thread_handle': _native_handle(getattr(process, 'thread', None)), + 'cleanup': deepcopy(getattr(process, 'cleanup_record', {}))} + try: + item['exit_code'] = process.poll() + except Exception as error: + item['poll_error'] = str(error) + job = getattr(process, 'job', None) + job_api = getattr(process, '_job_api', None) + if job is not None and job_api is not None: + try: + item['job_accounting'] = job_api.QueryInformationJobObject( + job, job_api.JobObjectBasicAccountingInformation) + except Exception as error: + item['job_query_error'] = str(error) + resources.append(item) + confirmation = getattr(self._api, 'desktop_release_check', None) or {} + return {'owned_processes': resources, + 'pending_launch_cleanup_count': len(getattr(self._api, '_pending_cleanup', [])), + 'residual_windows': deepcopy(confirmation.get('remaining_windows')), + 'window_query_error': confirmation.get('window_query_error'), + 'external_handle_holders': 'unknown', + 'thread_desktops': {'observations': deepcopy(confirmation.get('remaining_windows', [])), + 'complete': False, 'unobserved_threads': 'unknown'}, + 'empty_windows_prove_no_holders': False} diff --git a/mentorexport/_errors.py b/mentorexport/_errors.py new file mode 100644 index 0000000..364cd1d --- /dev/null +++ b/mentorexport/_errors.py @@ -0,0 +1,29 @@ +"""Stable, user-facing errors for trial task-center operations.""" + +from __future__ import annotations + +from datetime import datetime, timezone +import secrets + + +class TaskCenterError(ValueError): + """An operation failure with a durable support identifier and safe user text.""" + + def __init__( + self, + code: str, + message: str, + *, + error_id: str | None = None, + traceback_detail: str = "", + ) -> None: + self.code = code + self.message = message + self.error_id = error_id or self._new_error_id() + self.traceback_detail = traceback_detail + super().__init__(f"{self.error_id} {code}: {message}") + + @staticmethod + def _new_error_id() -> str: + date = datetime.now(timezone.utc).strftime("%Y%m%d") + return f"DXT-{date}-{secrets.token_hex(4).upper()}" diff --git a/mentorexport/_identity.py b/mentorexport/_identity.py new file mode 100644 index 0000000..ad57687 --- /dev/null +++ b/mentorexport/_identity.py @@ -0,0 +1,77 @@ +"""Identity certificate shared by the private desktop worker and native helper.""" +from dataclasses import dataclass +import ctypes +from ctypes import wintypes +import os +import re + + +def current_desktop_name(): + user = ctypes.WinDLL('user32', use_last_error=True) + kernel = ctypes.WinDLL('kernel32', use_last_error=True) + user.GetThreadDesktop.argtypes = [wintypes.DWORD] + user.GetThreadDesktop.restype = wintypes.HANDLE + user.GetUserObjectInformationW.argtypes = [wintypes.HANDLE, ctypes.c_int, ctypes.c_void_p, + wintypes.DWORD, ctypes.POINTER(wintypes.DWORD)] + desktop = user.GetThreadDesktop(kernel.GetCurrentThreadId()) + value, required = ctypes.create_unicode_buffer(256), wintypes.DWORD() + if not user.GetUserObjectInformationW(desktop, 2, value, ctypes.sizeof(value), ctypes.byref(required)): + raise ctypes.WinError(ctypes.get_last_error()) + return value.value + + +def window_pid(handle): + import win32process + return win32process.GetWindowThreadProcessId(handle)[1] + + +@dataclass(frozen=True, slots=True) +class CadBinding: + desktop: str + pid: int + guid: str + token: str + + @classmethod + def from_environment(cls, environment=None): + environment = os.environ if environment is None else environment + fields = ('DXPART_DESKTOP', 'DXPART_CAD_PID', 'DXPART_CAD_GUID', 'DXPART_SESSION_TOKEN') + values = [environment.get(field, '') for field in fields] + if not any(values): + return None + if not all(values): + raise ValueError('incomplete private CAD identity') + desktop, pid, guid, token = values + if not re.fullmatch(r'dx-[A-Za-z0-9-]{1,80}', desktop) or int(pid) <= 0: + raise ValueError('invalid private CAD desktop or PID') + if not re.fullmatch(r'[0-9a-f]{32}', token): + raise ValueError('invalid private CAD session token') + return cls(desktop, int(pid), guid, token) + + def environment(self): + return dict(os.environ, DXPART_DESKTOP=self.desktop, DXPART_CAD_PID=str(self.pid), + DXPART_CAD_GUID=self.guid, DXPART_SESSION_TOKEN=self.token) + + +def verify_application(app, binding=None, *, require_view=True): + binding = CadBinding.from_environment() if binding is None else binding + if binding is None: + return None + if current_desktop_name() != binding.desktop: + raise ValueError('CAD helper is not running on its owned desktop') + if str(app.Guid()).casefold() != binding.guid.casefold(): + raise ValueError('CAD COM GUID does not match its owned session') + if require_view: + handle = int(app.ActiveViewHandle) + if not handle or window_pid(handle) != binding.pid: + raise ValueError('CAD view PID does not match its owned session') + return binding + + +def project_file_path(app): + """COM type libraries expose this getter as either a property or a method.""" + value = app.GetProjectData().GetProjectFilePath + value = value() if callable(value) else value + if not isinstance(value, str): + raise ValueError('CAD returned an invalid project path') + return value diff --git a/mentorexport/cli.py b/mentorexport/cli.py new file mode 100644 index 0000000..28f3f4f --- /dev/null +++ b/mentorexport/cli.py @@ -0,0 +1,332 @@ +"""Interactive entry point and recoverable batch lifecycle.""" +import argparse +from datetime import datetime +import importlib +import os +from pathlib import Path +import signal +import sys +from threading import Event +import traceback +import uuid + +from . import __version__ +from .core import discover_projects, load_json, project_folder_name, read_project, sha256, write_json +from .environment import discover_installations, preflight_installation +from .report import LABELS, write_report + +APP_ROOT = Path(__file__).resolve().parent.parent + + +def validate_output(output, scan_root, projects): + output, scan_root = Path(output).resolve(), Path(scan_root).resolve() + if output == scan_root or output in scan_root.parents: + raise ValueError("结果目录不能是扫描目录本身或其父目录") + for project in projects: + protected = [] + if project.get("database"): + protected.append(Path(project["database"]).resolve()) + if project.get("library"): + protected.append(Path(project["library"]).resolve().parent) + for root in protected: + if output == root or root in output.parents: + raise ValueError("结果目录不能写入源数据库或中央库:" + str(output)) + + +def process_identity(pid): + import win32api + import win32process + try: + handle = win32api.OpenProcess(0x1000, False, int(pid)) + try: + created = win32process.GetProcessTimes(handle)["CreationTime"].isoformat() + return {"pid": int(pid), "created": created} + finally: + handle.Close() + except Exception as exc: + return {"pid": int(pid), "created": None, "query_error": str(exc)} + + +def assert_retry_safe(record): + if record.get("state") in ("complete", "cancelled"): + return + owner = record.get("owner") + if not owner: + raise ValueError("未完成批次缺少进程归属证据,请新建完整导出") + current = process_identity(owner["pid"]) + if current.get("created") and current["created"] == owner.get("created"): + raise ValueError("原批次进程仍在运行,请等待结束后重试") + if current.get("created") is None: + import win32api + try: + handle = win32api.OpenProcess(0x1000, False, owner["pid"]) + except Exception as exc: + if getattr(exc, "winerror", None) != 87: + raise ValueError("无法确认旧批次进程已退出,请稍后重试") from exc + else: + handle.Close() + raise ValueError("旧批次进程状态无法确认,请稍后重试") + + +def runtime_check(): + errors = [] + for name in ("win32api", "win32gui", "win32process", "win32event", "win32job", "win32service", "pythoncom"): + try: + importlib.import_module(name) + except (ImportError, OSError) as exc: + errors.append(f"{name}: {exc}") + manifest = load_json(APP_ROOT / "package-manifest.json", {}) + for name, item in manifest.get("files", {}).items(): + path = APP_ROOT / name + if not path.is_file(): + errors.append("缺失文件:" + name) + elif sha256(path) != item["sha256"]: + errors.append("文件摘要不匹配:" + name) + return errors + + +def previous_results(record): + values = {} + for row in record.get("projects", []): + result = load_json(Path(row["folder"]) / "export.json", row.get("result")) + if result: + values[row["project"]["path"]] = result + return values + + +def run_batch(projects, problems, installation, output_root, scan_root, *, previous=None, + stop_event=None, timeout=60, exporter=None, progress=print): + if exporter is None: + from .exports import export_project + exporter = export_project + stop_event = stop_event or Event() + output_root = Path(output_root).resolve() + validate_output(output_root, scan_root, projects) + output_root.mkdir(parents=True, exist_ok=True) + (output_root / ".mentor-export-output").write_text("MentorExport", encoding="ascii") + batch = output_root / (datetime.now().strftime("批次_%Y%m%d_%H%M%S_") + uuid.uuid4().hex[:6]) + batch.mkdir() + (batch / ".mentor-export-batch").write_text("MentorExport", encoding="ascii") + shared = batch / "_共享库数据" + shared.mkdir() + record = {"schema": 1, "version": __version__, "state": "running", + "scan_root": str(Path(scan_root).resolve()), "output_root": str(output_root), + "created": datetime.now().astimezone().isoformat(), "installation": installation, + "owner": process_identity(os.getpid()), + "problems": problems, "projects": []} + write_json(batch / "环境信息.json", installation) + prior = previous_results(previous or {}) + for project in projects: + record["projects"].append({"project": project, "folder": str(batch / project_folder_name(project, scan_root)), "status": "pending"}) + write_json(batch / "batch.json", record) + write_report(batch, record) + cleanup_uncertain = False + for index, row in enumerate(record["projects"], 1): + if stop_event.is_set(): + row["status"] = "cancelled" + row["result"] = {"status": "cancelled", "reason": "用户停止,尚未执行", "items": []} + write_json(Path(row["folder"]) / "export.json", row["result"]) + continue + project = row["project"] + row["status"] = "running" + write_json(batch / "batch.json", record) + progress(f"\n[{index}/{len(projects)}] {project['name']}") + try: + result = exporter(project, installation, Path(row["folder"]), shared, + previous=prior.get(project["path"]), stop_event=stop_event, + timeout=timeout, progress=progress) + row["result"] = result + row["status"] = result["status"] + if result.get("cleanup_uncertain"): + cleanup_uncertain = True + stop_event.set() + except KeyboardInterrupt: + stop_event.set() + row["status"] = "cancelled" + row["result"] = load_json(Path(row["folder"]) / "export.json", {"items": []}) + row["result"].update(status="cancelled", reason="用户停止") + except Exception as exc: + row["status"] = "failed" + row["result"] = load_json(Path(row["folder"]) / "export.json", {"items": []}) + row["result"].update(status="failed", reason=str(exc)) + folder = Path(row["folder"]) / "90_运行日志" + folder.mkdir(parents=True, exist_ok=True) + (folder / "exception.txt").write_text(traceback.format_exc(), encoding="utf-8") + if getattr(exc, "cleanup_uncertain", False): + cleanup_uncertain = True + stop_event.set() + row["result"]["cleanup_uncertain"] = True + Path(row["folder"]).mkdir(parents=True, exist_ok=True) + write_json(Path(row["folder"]) / "export.json", row["result"]) + write_json(batch / "batch.json", record) + write_report(batch, record) + progress("结果:" + LABELS.get(row["status"], row["status"])) + cancelled = stop_event.is_set() or any(p["status"] == "cancelled" for p in record["projects"]) + record["state"] = "attention_required" if cleanup_uncertain else ("cancelled" if cancelled else "complete") + record["finished"] = datetime.now().astimezone().isoformat() + code = 1 if cleanup_uncertain else (130 if cancelled else (1 if problems or not projects or any(p["status"] != "success" for p in record["projects"]) else 0)) + record["exit_code"] = code + write_json(batch / "batch.json", record) + write_report(batch, record) + return batch, code + + +def _settings_paths(): + return [APP_ROOT / "settings.json", + Path(os.environ.get("LOCALAPPDATA", str(Path.home()))) / "MentorExport/settings.json"] + + +def _save_settings(value): + for path in _settings_paths(): + try: + write_json(path, value) + return + except OSError: + continue + + +def _ask(prompt, default=None): + suffix = f" [{default}]" if default else "" + try: + value = input(prompt + suffix + ":").strip().strip('"') + except EOFError: + raise ValueError("输入结束;批处理调用请提供 --input、--output 和 --yes") + return value or default + + +def _choose_installation(args, settings): + installs = discover_installations(args.mentor_home, settings.get("mentor_home")) + if not installs: + if args.yes or args.check: + raise ValueError("未找到 Mentor,请使用 --mentor-home 指定 SDD_HOME") + installs = discover_installations(explicit=_ask("未找到 Mentor,请输入 SDD_HOME 或安装目录")) + if len(installs) > 1 and not args.mentor_home: + for i, install in enumerate(installs, 1): + print(f" {i}. {install['version']} {install['root']}") + if args.yes: + raise ValueError("发现多套 Mentor,请使用 --mentor-home 明确指定") + selected = int(_ask("选择 Mentor 安装编号", "1")) - 1 + if not 0 <= selected < len(installs): + raise ValueError("安装编号超出范围") + return installs[selected] + return installs[0] + + +def main(argv=None): + parser = argparse.ArgumentParser(description="便携 Mentor 原理图批量导出;无参数进入中文问答。") + parser.add_argument("--input", "-i", help="递归扫描文件夹") + parser.add_argument("--output", "-o", help="结果根目录,每次新建批次") + parser.add_argument("--mentor-home", help="指定 Mentor SDD_HOME") + parser.add_argument("--retry", help="重试已有批次,指定批次目录或 batch.json") + parser.add_argument("--timeout", type=float, default=60, help="单工具超时秒数,默认 60") + parser.add_argument("--yes", "-y", action="store_true", help="采用已给定参数运行,不显示交互菜单") + parser.add_argument("--check", action="store_true", help="只检查预置环境与 Mentor") + parser.add_argument("--json", action="store_true", help="环境检查以 JSON 输出") + parser.add_argument("--version", action="version", version=__version__) + args = parser.parse_args(argv) + try: + if args.timeout <= 0: + raise ValueError("超时必须大于 0") + errors = runtime_check() + if errors: + raise ValueError("预置运行环境不完整,请重新解压发行包:\n" + "\n".join(errors)) + settings = next((v for p in _settings_paths() if (v := load_json(p)) is not None), {}) + installation = _choose_installation(args, settings) + diagnostic_root = Path(os.environ.get("LOCALAPPDATA", str(Path.home()))) / "MentorExport/diagnostics" / uuid.uuid4().hex + installation["preflight"] = preflight_installation(installation, diagnostic_root / "mentor-help") + if installation["preflight"]["status"] != "success": + raise ValueError(installation["preflight"]["reason"] + "\n" + str(diagnostic_root)) + if args.check: + import json + print(json.dumps({"version": __version__, "python": sys.executable, "runtime_ok": True, + "installation": installation}, ensure_ascii=False, indent=2) if args.json else + f"运行环境正常。Mentor:{installation['version']} {installation['root']}") + return 0 + print(f"\nMentorExport {__version__} · 原理图详细导出") + print(f"Mentor:{installation['version']} {installation['root']}") + print("读取已保存的原理图。请先保存目标工程;工具仅在副本上运行。") + if not args.retry and settings.get("output"): + candidates = sorted(Path(settings["output"]).glob("批次_*/batch.json"), reverse=True)[:30] + unfinished = [path for path in candidates if (load_json(path, {}).get("state") in ("running", "attention_required"))] + if unfinished: + print("发现未完成批次:" + str(unfinished[0].parent)) + if not args.yes and _ask("输入 1 重试该批次;回车开始新批次") == "1": + return main(["--retry", str(unfinished[0]), "--mentor-home", installation["root"], + "--timeout", str(args.timeout)]) + previous = None + if args.retry: + previous_path = Path(args.retry) + if previous_path.is_dir(): + previous_path /= "batch.json" + previous = load_json(previous_path) + if not previous or previous.get("schema") != 1: + raise ValueError("无效批次记录:" + str(previous_path)) + assert_retry_safe(previous) + scan_root = Path(previous["scan_root"]).resolve() + output_root = Path(args.output or previous["output_root"]).resolve() + projects, problems = [], [] + candidates = [r["project"]["path"] for r in previous["projects"]] + candidates += [p["path"] for p in previous.get("problems", []) if p.get("path", "").lower().endswith(".prj")] + for path in dict.fromkeys(candidates): + try: + projects.append(read_project(path)) + except (OSError, ValueError) as exc: + problems.append({"path": path, "reason": str(exc)}) + print("重试模式:核对输入与成功产物,匹配项复用;输入已变化的工程完整重导。") + else: + chosen = args.input or (None if args.yes else _ask("输入扫描文件夹", settings.get("input"))) + if not chosen: + raise ValueError("请提供 --input 或输入扫描路径") + scan_root = Path(chosen).resolve(strict=True) + default_output = settings.get("output") or str(scan_root.parent / "Mentor导出结果") + chosen_output = args.output or (default_output if args.yes else _ask("输入结果根目录", default_output)) + output_root = Path(chosen_output).resolve() + if output_root == scan_root or output_root in scan_root.parents: + raise ValueError("结果目录必须与扫描目录独立,或位于其专用子目录,不能使用扫描目录本身/其父目录") + print("正在扫描工程……") + projects, problems = discover_projects(scan_root, excluded=(output_root,)) + print(f"可导出工程:{len(projects)};扫描问题:{len(problems)}") + validate_output(output_root, scan_root, projects) + print("输出目录:" + str(output_root)) + for project in projects: + print(f" {project['name']} · {project['root_block']} · {project['snapshot']}") + for problem in problems: + print(f" [扫描问题] {problem['path']}:{problem['reason']}") + if not args.yes and _ask("开始导出?输入 Y 确认", "Y").upper() not in ("Y", "YES"): + return 130 + _save_settings({"input": str(scan_root), "output": str(output_root), "mentor_home": installation["root"]}) + stop = Event() + old_handler = signal.getsignal(signal.SIGINT) + def cancel(signum, frame): + if not stop.is_set(): + print("\n已请求停止,正在收尾自有导出进程,请稍候……", flush=True) + stop.set() + signal.signal(signal.SIGINT, cancel) + try: + batch, code = run_batch(projects, problems, installation, output_root, scan_root, + previous=previous, stop_event=stop, timeout=args.timeout) + finally: + signal.signal(signal.SIGINT, old_handler) + record = load_json(batch / "batch.json") + counts = {} + for row in record["projects"]: + counts[row["status"]] = counts.get(row["status"], 0) + 1 + print("\n本批结束:" + " ".join(f"{LABELS.get(k, k)} {v}" for k, v in counts.items())) + print("汇总报告:" + str(batch / "导出汇总.html")) + print("下次重试:导出.cmd --retry \"" + str(batch) + "\"") + if not args.yes: + while True: + action = _ask("1 打开结果目录;2 打开汇总;3 重试未完成项;回车退出") + if not action: + break + if action in ("1", "2"): + os.startfile(str(batch if action == "1" else batch / "导出汇总.html")) + elif action == "3": + return main(["--retry", str(batch), "--mentor-home", installation["root"], "--timeout", str(args.timeout)]) + return code + except KeyboardInterrupt: + print("\n已取消。") + return 130 + except (ValueError, OSError) as exc: + print("\n无法开始:" + str(exc), file=sys.stderr) + return 2 diff --git a/mentorexport/core.py b/mentorexport/core.py new file mode 100644 index 0000000..928ef0f --- /dev/null +++ b/mentorexport/core.py @@ -0,0 +1,133 @@ +"""Project identity, filesystem discovery and atomic state utilities.""" +from pathlib import Path +import hashlib +import json +import os +import re +import uuid + + +def sha256(path): + with Path(path).open("rb") as stream: + return hashlib.file_digest(stream, "sha256").hexdigest() + + +def read_text(path): + data = Path(path).read_bytes() + try: + return data.decode("utf-8-sig") + except UnicodeDecodeError: + return data.decode("mbcs" if os.name == "nt" else "cp1252") + + +def write_json(path, value): + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + # Windows app-container redirection can otherwise make rename look cross-volume. + path = path.parent.resolve() / path.name + temporary = path.with_name(path.name + "." + uuid.uuid4().hex + ".tmp") + try: + temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2), encoding="utf-8") + os.replace(temporary, path) + finally: + temporary.unlink(missing_ok=True) + + +def load_json(path, default=None): + try: + return json.loads(Path(path).read_text(encoding="utf-8")) + except (OSError, ValueError): + return default + + +def _resolve_path(value, folder): + path = Path(os.path.expandvars(value.replace("\\", os.sep))) + return (path if path.is_absolute() else folder / path).resolve() + + +def read_project(path): + path = Path(path).resolve(strict=True) + if path.suffix.lower() != ".prj": + raise ValueError("需要 Mentor .prj 工程文件") + sections = {} + section = "" + for raw in read_text(path).splitlines(): + line = raw.strip() + if line.startswith("SECTION "): + section = line[8:].strip() + sections.setdefault(section, {}) + elif line == "ENDSECTION": + section = "" + elif line.startswith("KEY "): + match = re.fullmatch(r'KEY\s+(\S+)\s+(?:"([^"]*)"|(.+))', line) + if match: + sections.setdefault(section, {})[match[1]] = match[2] if match[2] is not None else match[3] + roots = [(name, values["RootBlock"]) for name, values in sections.items() if values.get("RootBlock")] + if not roots: + raise ValueError("工程没有可识别的 RootBlock,无法确定原理图") + if len(roots) != 1: + raise ValueError("工程包含多个根配置,请拆分/明确原理图配置后导出:" + "、".join(name for name, _ in roots)) + config, block = roots[0] + info = sections.get("DesignInfo", {}) + database = _resolve_path(sections.get("iCDB", {}).get("iCDBDir", "database"), path.parent) + if database.name.lower() == "icdb.dat": + database = database.parent + if not (database / "icdb.dat").is_file(): + raise ValueError("找不到已保存数据库:" + str(database / "icdb.dat")) + snapshot = info.get("FrontEndSnapshot", "DxD") + if not snapshot or not block: + raise ValueError("原理图根块或快照为空") + library = info.get("CentralLibrary") + return {"path": str(path), "name": path.stem, "database": str(database), + "root_block": block, "snapshot": snapshot, "configuration": config, + "library": str(_resolve_path(library, path.parent)) if library else None} + + +def discover_projects(root, excluded=()): + root = Path(root).resolve(strict=True) + if not root.is_dir(): + raise ValueError("扫描路径必须是文件夹") + excluded = [Path(path).resolve() for path in excluded] + projects, problems = [], [] + def error(exc): + problems.append({"path": str(exc.filename or root), "reason": str(exc)}) + for directory, folders, files in os.walk(root, topdown=True, followlinks=False, onerror=error): + folder = Path(directory) + keep = [] + for name in folders: + member = folder / name + try: + if name in (".git", "__pycache__") or member.is_symlink() or member.is_junction(): + continue + if any(member.resolve() == e or e in member.resolve().parents for e in excluded): + continue + if (member / ".mentor-export-batch").exists() or (member / ".mentor-export-output").exists(): + continue + keep.append(name) + except OSError as exc: + error(exc) + folders[:] = sorted(keep, key=str.casefold) + present = {name.casefold() for name in files} + for name in files: + if name.lower().endswith(".dxp") and (Path(name).stem + ".prj").casefold() not in present: + problems.append({"path": str((folder / name).resolve()), + "reason": "只有 .dxp,未找到同名 .prj;请提供可读取的工程,工具不会启动 Designer 转换"}) + for name in sorted(files, key=str.casefold): + if not name.lower().endswith(".prj"): + continue + path = folder / name + if path.is_symlink(): + problems.append({"path": str(path), "reason": "跳过符号链接工程,避免重复/越界访问"}) + continue + try: + projects.append(read_project(path)) + except (OSError, ValueError) as exc: + problems.append({"path": str(path.resolve()), "reason": str(exc)}) + return projects, problems + + +def project_folder_name(project, root=None): + path = Path(project["path"]).resolve() + digest = hashlib.sha256(os.path.normcase(str(path)).encode("utf-8")).hexdigest()[:8] + name = re.sub(r'[<>:"/\\|?*\x00-\x1f]', "_", project["name"]).rstrip(" .")[:64] or "工程" + return f"{name}__{digest}" diff --git a/mentorexport/environment.py b/mentorexport/environment.py new file mode 100644 index 0000000..225abab --- /dev/null +++ b/mentorexport/environment.py @@ -0,0 +1,178 @@ +"""Discover locally installed Mentor tools without starting Designer.""" +from pathlib import Path +import os +import re +from .core import sha256 + +TOOL_PATHS = { + "ascii": "iCDB/win32/bin/icdb2ascii.exe", + "csv": "iCDB/win32/bin/icdb2csv.exe", + "keyin": "wv/win32/bin/KeyinNetlist.exe", + "rinf": "wv/win32/bin/RinfNetlist.exe", + "edif": "wv/win32/bin/edifExporter.exe", + "wir": "wv/win32/bin/icdb2wir.exe", + "pxr": "wv/win32/bin/icdb2pxr.exe", + "constraints_xml": "ces/win32/bin/cons2xml.exe", +} +VALIDATED_DLLS = { + "PartsDB40.dll": "f24d44eaa13f28550317711df6a6241e227ae56805baa73c8f3020bde513ad0d", + "CellDB40.dll": "e3fb93a0b5e5d2d027a82f71d1ee13d497598f709ced54c9145a781af6a54d26", +} + + +def _registry_module(progid): + if os.name != "nt": + return None + import winreg + try: + view = winreg.KEY_READ | winreg.KEY_WOW64_32KEY + with winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, progid + r"\CLSID", 0, view) as key: + clsid = winreg.QueryValue(key, None) + for server in ("InprocServer32", "LocalServer32"): + try: + with winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, "CLSID\\" + clsid + "\\" + server, 0, view) as key: + command = os.path.expandvars(winreg.QueryValue(key, None)).strip() + match = re.match(r'^"([^"]+)"', command) or re.match(r"^(.+?\.(?:dll|exe|ocx))(?:\s|$)", command, re.I) + return str(Path(match[1] if match else command).resolve()) + except OSError: + continue + except OSError: + pass + return None + + +def _root_from_path(path): + path = Path(os.path.expandvars(str(path))).expanduser().resolve() + for candidate in (path, *path.parents): + if (candidate / TOOL_PATHS["ascii"]).is_file(): + return candidate + if (path / "SDD_HOME").is_dir(): + return path / "SDD_HOME" + return path + + +def inspect_installation(path): + root = _root_from_path(path) + tools = {name: str(root / relative) for name, relative in TOOL_PATHS.items() if (root / relative).is_file()} + version = root.parent.name + file_version = None + if os.name == "nt": + try: + import win32api + info = win32api.GetFileVersionInfo(str(root / "wv/win32/bin/viewdraw.exe"), "\\") + ms, ls = info["FileVersionMS"], info["FileVersionLS"] + file_version = f"{ms >> 16}.{ms & 65535}.{ls >> 16}.{ls & 65535}" + except Exception: + pass + hashes = {} + for name in VALIDATED_DLLS: + file = root / "common/win32/lib" / name + if file.is_file(): + hashes[name] = sha256(file) + com = {} + for name, progid in (("cms", "CMS.CeObjectDefsICDB"), ("central", "CentralLibSvr.LibPart.1")): + registered = _registry_module(progid) + matches = bool(registered and Path(registered).is_relative_to(root)) + com[name] = {"registered_path": registered, "matches": matches} + return {"root": str(root), "version": version, "file_version": file_version, "tools": tools, + "native_compatible": hashes == VALIDATED_DLLS, "dll_hashes": hashes, "com": com} + + +def _registry_candidates(): + if os.name != "nt": + return [] + import winreg + paths = [] + for progid in ("ViewDraw.Application", "ViewDraw.Application.1", "CMS.CeObjectDefsICDB", "CentralLibSvr.LibPart.1"): + value = _registry_module(progid) + if value: + paths.append(value) + for hive in (winreg.HKEY_LOCAL_MACHINE, winreg.HKEY_CURRENT_USER): + for view in (winreg.KEY_WOW64_32KEY, winreg.KEY_WOW64_64KEY): + try: + with winreg.OpenKey(hive, r"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall", 0, winreg.KEY_READ | view) as parent: + for index in range(winreg.QueryInfoKey(parent)[0]): + try: + with winreg.OpenKey(parent, winreg.EnumKey(parent, index)) as key: + display = str(winreg.QueryValueEx(key, "DisplayName")[0]) + if re.search(r"mentor|xpedition|expedition|dxdesigner", display, re.I): + value = str(winreg.QueryValueEx(key, "InstallLocation")[0]) + if value: + paths.append(value) + except OSError: + continue + except OSError: + continue + return paths + + +def _conventional_candidates(): + candidates = [] + for drive in "CDEFG": + for name in ("Mentor", "MentorGraphics", "Siemens", "Program Files/MentorGraphics", "Program Files/Siemens", "Program Files (x86)/MentorGraphics"): + root = Path(f"{drive}:/{name}") + if not root.is_dir(): + continue + seen = 0 + for folder, names, files in os.walk(root, followlinks=False): + path = Path(folder) + seen += 1 + if path.name.casefold() == "sdd_home": + candidates.append(path) + names[:] = [] + elif len(path.relative_to(root).parts) >= 3 or seen >= 500: + names[:] = [] + else: + names[:] = [name for name in names if not (path / name).is_junction() and not (path / name).is_symlink()] + return candidates + + +def discover_installations(explicit=None, cached=None): + if explicit: + candidate = inspect_installation(explicit) + if "ascii" not in candidate["tools"]: + raise ValueError("该目录没有可用的 icdb2ascii.exe,请选择完整 Mentor 的 SDD_HOME:" + str(explicit)) + return [candidate] + values = [path for path in (cached, os.environ.get("SDD_HOME")) if path] + values.extend(_registry_candidates()) + values.extend(_conventional_candidates()) + results, seen = [], set() + for value in values: + try: + root = _root_from_path(value) + identity = os.path.normcase(str(root)) + if identity in seen: + continue + seen.add(identity) + if not (root / TOOL_PATHS["ascii"]).is_file(): + continue + results.append(inspect_installation(root)) + except (OSError, ValueError): + continue + return results + + +def preflight_installation(installation, log_dir, runner=None): + """Execute a harmless help request with the same private process boundary.""" + from .exports import _environment, _run + from .core import read_text + runner = runner or _run + log_dir = Path(log_dir) + log_dir.parent.mkdir(parents=True, exist_ok=True) + log_dir = log_dir.parent.resolve() / log_dir.name + tool = installation.get("tools", {}).get("ascii") + if not tool: + return {"status": "failed", "reason": "没有 icdb2ascii.exe"} + result = runner([tool, "-help"], log_dir.parent, _environment(installation), log_dir, + stop_event=None, timeout=10) + text = "" + for name in ("stdout.txt", "stderr.txt"): + path = log_dir / name + if path.is_file(): + text += read_text(path) + valid = (result.get("exit_code") == 0 and not result.get("timed_out") + and not result.get("error") and not result.get("cleanup_uncertain") + and not result.get("cleanup", {}).get("errors") + and "iCDB2Ascii" in text and "-snap=" in text and "-offline" in text) + return {"status": "success" if valid else "failed", "run": result, "log_dir": str(log_dir), + "reason": "" if valid else "Mentor 工具无法正常显示预期帮助;检查安装/DLL,详见预检日志"} diff --git a/mentorexport/exports.py b/mentorexport/exports.py new file mode 100644 index 0000000..d44d14d --- /dev/null +++ b/mentorexport/exports.py @@ -0,0 +1,656 @@ +"""Saved-project exports through short lived, owned, isolated tool processes.""" +from copy import deepcopy +from contextlib import contextmanager +import ctypes +from datetime import datetime, timezone +import hashlib +import json +import os +from pathlib import Path +import re +import shutil +import tempfile +import time +import uuid + +from .core import read_text, sha256, write_json +from ._desktop import PrivateDesktop + +HELPERS = Path(__file__).resolve().parent.parent / "helpers" +ITEMS = ( + ("ascii_flat", "ascii", "02_器件与引脚属性/icdb2ascii_平铺有效值"), + ("ascii_hier", "ascii", "02_器件与引脚属性/icdb2ascii_分层值"), + ("csv", "csv", "02_器件与引脚属性/icdb2csv"), + ("wir_oat", "wir", "02_器件与引脚属性/WIR_OAT"), + ("keyin", "keyin", "01_连接网表/KeyinNetlist"), + ("rinf", "rinf", "01_连接网表/RinfNetlist"), + ("pxr", "pxr", "01_连接网表/PXR"), + ("edif_netlist", "edif", "01_连接网表/EDIF_Netlist"), + ("edif_schematic", "edif", "03_位置与显示/EDIF_Schematic"), + ("constraints", "cms", "04_电气约束/CMS"), + ("library", "native", "05_关联库件与封装"), +) +VALIDATED_DLLS = { + "PartsDB40.dll": "f24d44eaa13f28550317711df6a6241e227ae56805baa73c8f3020bde513ad0d", + "CellDB40.dll": "e3fb93a0b5e5d2d027a82f71d1ee13d497598f709ced54c9145a781af6a54d26", +} +_UNCERTAIN_DESKTOPS = [] +_LIBRARY_CACHE = {} + + +@contextmanager +def _workspace(result): + path = Path(tempfile.mkdtemp(prefix="mexp-")) + try: + yield path + finally: + if result.get("cleanup_uncertain"): + result.setdefault("workspace_preserved", str(path)) + else: + shutil.rmtree(path) + + +def _digest(value): + return hashlib.sha256(json.dumps(value, sort_keys=True, ensure_ascii=False).encode("utf-8")).hexdigest() + + +def _short(path): + path = str(Path(path).resolve()) + if os.name == "nt": + function = ctypes.windll.kernel32.GetShortPathNameW + buffer = ctypes.create_unicode_buffer(32768) + if function(path, buffer, len(buffer)): + return Path(buffer.value) + return Path(path) + + +def _environment(installation): + root = Path(installation["root"]) + env = dict(os.environ, SDD_HOME=str(root), SDD_PLATFORM="win32", PYTHONIOENCODING="utf-8") + locations = ("common/win32/lib", "common/win32/bin", "wv/win32/bin", "iCDB/win32/bin", "ces/win32/bin") + # Drop alternate Mentor entries instead of allowing a second installation's DLLs. + inherited = [p for p in env.get("PATH", "").split(os.pathsep) if "sdd_home" not in p.lower()] + env["PATH"] = os.pathsep.join([str(root / p) for p in locations] + inherited) + return env + + +def _run(command, cwd, environment, log_dir, *, stop_event, timeout): + """The single process boundary; only its own desktop and Job are closed.""" + log_dir = Path(log_dir) + log_dir.mkdir(parents=True, exist_ok=True) + desktop = PrivateDesktop("mexp-" + uuid.uuid4().hex, enabled=True) + result = {"command": list(map(str, command)), "cwd": str(cwd), "exit_code": None, + "timed_out": False, "cancelled": False} + started = time.monotonic() + try: + with desktop: + with (log_dir / "stdout.txt").open("wb") as stdout, (log_dir / "stderr.txt").open("wb") as stderr: + process = desktop.start_process(tuple(map(str, command)), cwd=Path(cwd), env=environment, + stdout=stdout, stderr=stderr) + result["pid"] = process.pid + while process.poll() is None: + if stop_event is not None and stop_event.is_set(): + result["cancelled"] = True + break + if time.monotonic() - started >= timeout: + result["timed_out"] = True + try: + result["dialogs"] = desktop.inspect_dialogs(process.pid) + except Exception as error: + result["dialog_inspection_error"] = str(error) + break + time.sleep(0.05) + result["exit_code"] = process.poll() + except Exception as error: + result["error"] = str(error) + finally: + result["seconds"] = round(time.monotonic() - started, 3) + result["cleanup"] = desktop.cleanup_record + cleanup = result["cleanup"] or {} + if cleanup.get("errors") or any(p.get("job_active_processes", 0) for p in cleanup.get("processes", [])): + result["cleanup_uncertain"] = True + # Retain owned handles for further cleanup instead of abandoning live resources. + _UNCERTAIN_DESKTOPS.append(desktop) + write_json(log_dir / "run.json", result) + return result + + +def _inputs(project): + path, database = Path(project["path"]), Path(project["database"]) + files = {"input.prj": path, "database/icdb.dat": database / "icdb.dat"} + # Inputs used by CSV/CMS, copied without server addresses or live server state. + for relative in ("Integration/AugmentedPins.txt", "dxnetlister.ini", "speccomp.ini"): + source = path.parent / relative + if source.is_file(): + files[relative] = source + return files + + +def _hashes(files): + return {str(path.resolve()): sha256(path) for path in files.values()} + + +def _library_sources(project): + if not project.get("library"): + return {} + library = Path(project["library"]) + root = library.parent if library.is_file() else library + if not root.is_dir(): + return {} + sources = {} + for folder, pattern in (("PartsDBLibs", "*.pdb"), ("CellDBLibs", "*.cel")): + for path in sorted((root / folder).glob(pattern)): + sources[str(path.relative_to(root))] = path + for path in root.glob("*.lmc"): + sources[path.name] = path + return sources + + +def _capture(project, destination): + files = _inputs(project) + before = _hashes(files) + for relative, source in files.items(): + target = destination / relative + target.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(source, target) + if sha256(target) != before[str(source.resolve())]: + raise ValueError("Source changed during capture; save the project and retry") + if before != _hashes(_inputs(project)): + raise ValueError("Source changed during capture; save the project and retry") + text = read_text(destination / "input.prj") + for name, value in (("iCDBDir", "database"), ("DedicatedServerName", ""), ("CentralLibrary", "")): + text = re.sub(r"(?m)^(\s*KEY\s+" + name + r"\s+).*$", lambda m: m[1] + '"' + value + '"', text) + (destination / "input.prj").write_text(text, encoding="utf-8") + return before + + +def _file_info(path): + path = Path(path).resolve() + return {"path": str(path), "size": path.stat().st_size, "sha256": sha256(path)} + + +def _tool_identity(key, tool, installation): + if tool == "cms": + info = installation.get("com", {}).get("cms", {}) + path = info.get("registered_path") + return {"path": path, "sha256": sha256(path) if path and Path(path).is_file() else None, + "matches": info.get("matches", False), "helper_sha256": sha256(HELPERS / "constraints_read.vbs"), + "definitions_sha256": sha256(Path(installation["root"]) / "standard/ce_ee.cns") + if (Path(installation["root"]) / "standard/ce_ee.cns").is_file() else None} + if tool == "native": + path = HELPERS / "native_read.exe" + root = Path(installation["root"]) / "common/win32/lib" + return {"path": str(path), "sha256": sha256(path) if path.is_file() else None, + "dlls": {name: sha256(root / name) for name in VALIDATED_DLLS if (root / name).is_file()}} + path = installation.get("tools", {}).get(tool) + return {"path": path, "sha256": sha256(path) if path and Path(path).is_file() else None} + + +def _command(key, executable, project, work, output, installation): + prj, db = work / "input.prj", work / "database" + snapshot, top = project["snapshot"], project["root_block"] + if key.startswith("ascii_"): + return [executable, f"-project={prj}", f"-icdb={db}", f"-snap={snapshot}", + "-f" if key == "ascii_flat" else "-h", "-t", "-c", "-offline", f"-file={output / 'connections.txt'}"] + if key == "csv": + return [executable, f"-project={prj}", f"-icdb={db}", f"-snap={snapshot}", + "-properties", "-offline", f"-output={output}", "-file=design.csv"] + if key == "wir_oat": + for name in ("wir", "oat"): + (output / name).mkdir() + return [executable, f"-prj={prj}", f"-icdb={db}", f"-snap={snapshot}", f"-top={top}", + f"-wir={output / 'wir'}", f"-oat={output / 'oat'}", "-preserve"] + if key in ("keyin", "rinf"): + name = "design.kyn" if key == "keyin" else "design.frs" + return [executable, f"-block={top}", f"-icdbdir={db}", f"-icdbsnapshot={snapshot}", + "-flowtype=DX", f"-out={output / name}"] + if key == "pxr": + return [executable, "--icdb", str(db), "--snap", snapshot, "--top", top, "--flow", "DX", "--out", str(output / "design.pxr")] + if key.startswith("edif_"): + return [executable] + (["-schematic"] if key == "edif_schematic" else []) + [ + "-icdb", str(db), "-isnap", snapshot, "-top", top, "-o", str(output / "design.edf")] + if key == "constraints": + return [str(Path(os.environ.get("SystemRoot", "C:/Windows")) / "SysWOW64/cscript.exe"), "//nologo", + str(HELPERS / "constraints_read.vbs"), str(prj), str(output / "constraints.jsonl"), + str(Path(installation["root"]) / "standard/ce_ee.cns"), snapshot, top] + raise ValueError(key) + + +def _validate(key, output): + files = sorted(p for p in output.rglob("*") if p.is_file()) + if not files: + raise ValueError("No output files were produced") + if key == "csv": + manifest = output / "work/design.csv" + if not manifest.is_file(): + raise ValueError("CSV output manifest missing") + names = [line[5:].strip() for line in read_text(manifest).splitlines() if line.startswith("file:")] + if not names or any(Path(n).name != n for n in names): + raise ValueError("Invalid CSV output manifest") + tables = {Path(n).suffix[1:] for n in names} + if not {"sym", "spn", "spr", "ppr", "prm", "ppn", "prt", "pth", "sht", "inf", "npr", "thn"}.issubset(tables): + raise ValueError("CSV output manifest omits required relational tables") + for name in names: + table = manifest.parent / name + if not table.is_file() or not table.stat().st_size: + raise ValueError("CSV output table missing/empty: " + name) + if table.suffix != ".esf" and "\t" not in read_text(table).splitlines()[0]: + raise ValueError("CSV output table header is not tab separated: " + name) + return files + if key == "wir_oat": + wire = [p for p in files if p.parent.name == "wir"] + oat = [p for p in files if p.parent.name == "oat"] + if (not wire or not oat or any("Wirelist" not in read_text(p)[:200] for p in wire) + or any(not re.match(r"V\s+\d", read_text(p)) for p in oat)): + raise ValueError("WIR/OAT output incomplete or unrecognized") + return files + path = output / {"ascii_flat": "connections.txt", "ascii_hier": "connections.txt", "keyin": "design.kyn", + "rinf": "design.frs", "pxr": "design.pxr", "edif_netlist": "design.edf", + "edif_schematic": "design.edf", "constraints": "constraints.jsonl"}[key] + if not path.is_file() or not path.stat().st_size: + raise ValueError("Expected output file missing or empty: " + path.name) + text = path.read_text(encoding="utf-16") if key == "constraints" else read_text(path) + markers = {"ascii_flat": (r"iCDB Ascii Report", r"(?m)^Config\s"), + "ascii_hier": (r"iCDB Ascii Report", r"(?m)^Block\s"), + "keyin": (r"%net", r"%page="), "rinf": (r"\.HEA", r"\.APP"), "pxr": (r"Net_Cross_Reference",), + "edif_netlist": (r"\(edif\s", r"\(net\s"), "edif_schematic": (r"\(edif\s", r"\(page\s")} + if key in markers and not all(re.search(pattern, text, re.I) for pattern in markers[key]): + raise ValueError("Output format validation failed: " + path.name) + if key == "constraints": + rows = [json.loads(line) for line in text.splitlines() if line.strip()] + if not rows or rows[0].get("kind") != "initialization" or rows[-1].get("kind") != "complete": + raise ValueError("CMS output has no completion marker") + if int(rows[-1]["count"]) != sum(r.get("kind") == "constraint" for r in rows): + raise ValueError("CMS output count mismatch") + if any(r.get("error") for r in rows): + raise ValueError("CMS output contains failed field getters") + return [path] + + +def _reusable(old, fingerprint, identity): + if not old or old.get("status") != "success" or old.get("provenance", {}).get("input_fingerprint") != fingerprint: + return False + provenance = old["provenance"] + if provenance.get("tool") != identity or not old.get("outputs"): + return False + infos = provenance.get("output_files", []) + try: + return len(infos) == len(old["outputs"]) and all(_file_info(i["path"]) == i for i in infos) + except OSError: + return False + + +def _status(items): + states = [i["status"] for i in items] + if "cancelled" in states: + return "cancelled" + if states and all(s == "success" for s in states): + return "success" + return "partial" if "success" in states else "failed" + + +def export_project(project, installation, project_dir, shared_dir, *, previous=None, stop_event=None, timeout=45, progress=print): + project_dir = Path(project_dir).resolve() + project_dir.mkdir(parents=True, exist_ok=True) + shared_dir = Path(shared_dir).resolve() + result = {"status": "running", "project": deepcopy(project), "captured_at": datetime.now(timezone.utc).isoformat(), + "source_fingerprint": None, "source_hashes": {}, "items": [], "source_unchanged": None, + "coverage_limits": ["Exports preserve each tool/mode separately; no ERC or manufacturing certification.", + "CMS requests read mode but may report ReadOnly=False; only isolated copies are opened.", + "Cell coordinate units and rotation remain native integers; multi-slot/swappable mappings unverified."]} + state = project_dir / "export.json" + write_json(state, result) + if _UNCERTAIN_DESKTOPS: + result.update(status="failed", cleanup_uncertain=True, + reason="A previous owned process has unconfirmed cleanup; restart only after resolving its recorded Job/processes") + write_json(state, result) + return result + with _workspace(result) as temporary: + temp = _short(temporary) + captured = temp / "saved" + captured.mkdir() + try: + result["source_hashes"] = _capture(project, captured) + result["library_source_hashes"] = _hashes(_library_sources(project)) + fingerprint = _digest({"source": result["source_hashes"], "snapshot": project["snapshot"], + "root_block": project["root_block"], "configuration": project.get("configuration"), + "library": result["library_source_hashes"]}) + result["source_fingerprint"] = fingerprint + except Exception as error: + result.update(status="failed", reason=str(error), source_unchanged=False) + write_json(state, result) + return result + environment = _environment(installation) + old_items = {i["key"]: i for i in (previous or {}).get("items", [])} + discovery = {"status": "failed", "names": []} + result["snapshot_discovery"] = discovery + try: + snapshot_work = temp / "snapshot-discovery" + shutil.copytree(captured, snapshot_work) + discovery.update(_snapshot_metadata(project, installation, snapshot_work, + project_dir / "90_运行日志" / "snapshots", stop_event=stop_event, + timeout=min(timeout, 20))) + if discovery.get("cleanup_uncertain"): + result.update(cleanup_uncertain=True, workspace_preserved=str(temp)) + except Exception as error: + discovery.update(status="failed", reason=str(error)) + if discovery["status"] != "success": + result["coverage_limits"].append("Other snapshot names were not obtained: " + discovery.get("reason", "")) + write_json(state, result) + for key, tool, folder in ITEMS: + output = None + item = {"key": key, "status": "failed", "reason": "", "outputs": [], "provenance": {}} + result["items"].append(item) + try: + progress(project["name"] + ": " + key) + identity = _tool_identity(key, tool, installation) + item["provenance"] = {"tool": identity, "snapshot": project["snapshot"], "root_block": project["root_block"], + "installation": installation["root"], "version": installation.get("version"), + "input_fingerprint": fingerprint, "reused": False} + if result.get("cleanup_uncertain"): + item.update(status="cancelled", reason="Not launched: previous owned process cleanup is uncertain") + continue + if stop_event is not None and stop_event.is_set(): + item.update(status="cancelled", reason="Cancelled before launch") + continue + if _reusable(old_items.get(key), fingerprint, identity): + item.update(deepcopy(old_items[key])) + item["provenance"]["reused"] = True + item["reason"] = "Verified previous successful output reused" + continue + if key == "library": + _export_library(item, project, installation, result, project_dir / folder, shared_dir, + temp, environment, stop_event, timeout) + continue + if not identity.get("sha256") or (tool == "cms" and not identity.get("matches")): + item.update(status="unavailable", reason="Tool missing or COM registration does not match selected installation") + continue + work = temp / key + shutil.copytree(captured, work) + output = work / "output" + output.mkdir() + command = _command(key, identity.get("path"), project, work, output, installation) + log_dir = project_dir / "90_运行日志" / key + run = _run(command, work, environment, log_dir, stop_event=stop_event, timeout=timeout) + item["provenance"].update(run) + item["provenance"]["log_dir"] = str(log_dir) + if run.get("cleanup_uncertain"): + result.update(cleanup_uncertain=True, workspace_preserved=str(temp)) + item["reason"] = "Owned process cleanup is uncertain; workspace preserved and later tools stopped" + elif run.get("cancelled"): + item.update(status="cancelled", reason="Cancelled while tool was running") + elif run.get("timed_out"): + item["reason"] = "Tool timed out; owned Job cleaned up" + elif run.get("error") or run.get("exit_code") != 0 or run.get("cleanup", {}).get("errors"): + item["reason"] = run.get("error") or "Tool exited unsuccessfully or process cleanup failed" + else: + files = _validate(key, output) + destination = project_dir / folder + published = [] + for file in files: + target = destination / file.relative_to(output) + target.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(file, target) + published.append(target) + item.update(status="success", outputs=[str(p) for p in published]) + item["provenance"]["output_files"] = [_file_info(p) for p in published] + except Exception as error: + item.update(status="failed", reason=str(error)) + finally: + if item["status"] in ("failed", "cancelled") and output is not None: + try: + evidence = project_dir / "90_运行日志" / key / "failed-output" + saved = [] + for source in output.rglob("*"): + if source.is_file(): + target = evidence / source.relative_to(output) + target.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(source, target) + saved.append(_file_info(target)) + if saved: + item["provenance"]["failed_output_files"] = saved + except OSError as error: + item["provenance"]["failure_evidence_error"] = str(error) + result["status"] = "running" + write_json(state, result) + try: + after = _hashes(_inputs(project)) + result["source_hashes_after"] = after + result["library_source_hashes_after"] = _hashes(_library_sources(project)) + result["source_unchanged"] = (after == result["source_hashes"] and + result["library_source_hashes_after"] == result["library_source_hashes"]) + except OSError as error: + result["source_unchanged"] = False + result["source_check_error"] = str(error) + if not result["source_unchanged"]: + for item in result["items"]: + if item["status"] == "success": + item.update(status="failed", reason="Source changed during export; save and run a full new attempt") + result["status"] = "failed" if result.get("cleanup_uncertain") else _status(result["items"]) + write_json(state, result) + return result + + +def _snapshot_metadata(project, installation, work, log, *, stop_event, timeout): + metadata = {"status": "unavailable", "names": [], "log_dir": str(log)} + executable = installation.get("tools", {}).get("constraints_xml") + if not executable: + metadata["reason"] = "Snapshot listing tool unavailable" + return metadata + if stop_event is not None and stop_event.is_set(): + metadata.update(status="cancelled", reason="Cancelled before snapshot discovery") + return metadata + run = _run([executable, "-list", "-icdb", str(work / "database")], work, _environment(installation), + log, stop_event=stop_event, timeout=timeout) + metadata.update(status="failed", run=run) + if run.get("cleanup_uncertain"): + metadata.update(cleanup_uncertain=True, workspace_preserved=str(work), + reason="Snapshot process cleanup uncertain; workspace preserved") + elif run.get("cancelled"): + metadata.update(status="cancelled", reason="Snapshot discovery cancelled") + elif run.get("exit_code") != 0 or run.get("error") or run.get("timed_out"): + metadata["reason"] = "Snapshot listing failed or timed out; see run log" + else: + metadata["names"] = list(dict.fromkeys(re.findall(r"(?m)^\s*->\s*(\S.*?)\s*$", read_text(log / "stdout.txt")))) + if project["snapshot"] in metadata["names"]: + metadata.update(status="success", reason="Names only; configured schematic snapshot remains selected") + else: + metadata["reason"] = "Configured snapshot was not found in listing" + return metadata + + +def list_snapshots(project, installation, work_dir): + """List snapshot names using a disposable copy; never changes default selection.""" + executable = installation.get("tools", {}).get("constraints_xml") + if not executable: + return [] + if _UNCERTAIN_DESKTOPS: + raise RuntimeError("A prior owned process has unconfirmed cleanup; snapshot discovery stopped") + workspace_state = {} + with _workspace(workspace_state) as temporary: + work = _short(temporary) + _capture(project, work) + metadata = _snapshot_metadata(project, installation, work, Path(work_dir) / "snapshots", + stop_event=None, timeout=20) + if metadata.get("cleanup_uncertain"): + workspace_state.update(cleanup_uncertain=True, workspace_preserved=str(work)) + raise RuntimeError("Snapshot process cleanup uncertain; workspace preserved: " + str(work)) + return metadata["names"] + + +def _export_library(item, project, installation, result, destination, shared_dir, temp, environment, stop_event, timeout): + identity = item["provenance"]["tool"] + if identity.get("dlls") != VALIDATED_DLLS: + item.update(status="unavailable", reason="Native DLL ABI is unverified; exact PartsDB40/CellDB40 SHA256 required") + return + if not identity.get("sha256"): + item.update(status="unavailable", reason="Native library reader executable missing") + return + sources = _library_sources(project) + if not sources: + item.update(status="unavailable", reason="Central library missing or contains no local PDB/CEL partitions") + return + references = {"parts": set(), "cell": set()} + flat = next((i for i in result["items"] if i["key"] == "ascii_flat" and i["status"] == "success"), None) + if not flat: + item.update(status="unavailable", reason="Effective ASCII properties required to identify actually used parts/cells") + return + for line in read_text(flat["outputs"][0]).splitlines(): + match = re.match(r"\s*Prop\s+(Part Number|Cell Name)\s+(.+?)\s*$", line) + if match: + references["parts" if match[1] == "Part Number" else "cell"].add(match[2]) + if not any(references.values()): + item.update(status="unavailable", reason="No used Part Number / Cell Name properties found") + return + source_hashes = result["library_source_hashes"] + fingerprint = _digest({"sources": source_hashes, "tool": identity}) + request = {mode: sorted(names) for mode, names in references.items()} + shared = shared_dir / fingerprint[:24] + shared.mkdir(parents=True, exist_ok=True) + data_path = shared / ("used-" + _digest(request)[:20] + ".json") + data = None + if data_path.is_file(): + try: + cached = json.loads(data_path.read_text(encoding="utf-8")) + if (cached.get("complete") and cached.get("fingerprint") == fingerprint and cached.get("request") == request + and cached.get("records_sha256") == _digest(cached.get("records"))): + data = cached + item["provenance"]["reused"] = True + except (OSError, ValueError): + pass + if data is None: + data = {"fingerprint": fingerprint, "source_hashes": source_hashes, "request": request, + "complete": False, "records": {"parts": [], "cell": []}, "runs": [], "errors": [], + "coverage_limits": ["Only actually referenced effective part numbers/cells are retained.", + "Current library mapping is not proof of the historical library version.", + "Symbol pin ordinals and cell pad names are separate data; multi-slot/swappable mapping unverified.", + "Cell geometry retains native unit codes; copper/drill/mask shapes are not decoded."]} + def persist(): + data["records_sha256"] = _digest(data["records"]) + write_json(data_path, data) + item["outputs"] = [str(data_path)] + item["provenance"].update(library_fingerprint=fingerprint, library_source_hashes=source_hashes, + output_files=[_file_info(data_path)]) + persist() + dll_dir = Path(installation["root"]) / "common/win32/lib" + partitions = _LIBRARY_CACHE.setdefault(fingerprint, {}) + for index, (relative, source) in enumerate(sources.items()): + if source.suffix.lower() not in (".pdb", ".cel"): + continue + if stop_event is not None and stop_event.is_set(): + item.update(status="cancelled", reason="Library reading cancelled") + return + mode = "parts" if source.suffix.lower() == ".pdb" else "cell" + if not references[mode]: + continue + known = partitions.get(relative) + if known is not None: + needed = references[mode] & known["names"] + available = {row["name"] for row in known["selected"]} + if needed <= available: + data["records"][mode].extend(deepcopy(row) for row in known["selected"] if row["name"] in needed) + data["runs"].append({"partition": relative, "reused_partition": True, + "original_run": deepcopy(known["run"])}) + persist() + continue + work = temp / ("library-" + str(index)) + work.mkdir() + copied = work / ("input" + source.suffix) + shutil.copyfile(source, copied) + if sha256(copied) != source_hashes[str(source.resolve())]: + raise ValueError("Library changed during capture; run a complete new attempt") + log = destination.parent / "90_运行日志" / "library" / f"{index:03d}" + command = [str(HELPERS / "native_read.exe"), mode, str(dll_dir), str(copied)] + run = _run(command, work, environment, log, stop_event=stop_event, timeout=timeout) + run["partition"] = relative + run["log_dir"] = str(log) + run["stdout_retained"] = True + write_json(log / "run.json", run) + data["runs"].append(run) + persist() + if run.get("cleanup_uncertain"): + result.update(cleanup_uncertain=True, workspace_preserved=str(temp)) + item.update(status="failed", reason="Library reader cleanup uncertain; workspace preserved and batch must stop") + item["provenance"]["uncertain_run"] = run + return + if run.get("cancelled"): + item.update(status="cancelled", reason="Library reading cancelled") + return + if run.get("exit_code") != 0 or run.get("error") or run.get("timed_out") or run.get("cleanup", {}).get("errors"): + data["errors"].append({"partition": relative, "reason": run.get("error") or "Native read failed/timeout/cleanup error"}) + persist() + continue + try: + native = json.loads((log / "stdout.txt").read_text(encoding="utf-8")) + _validate_native(native, mode) + selected = [] + for row in native["records"]: + if row.get("name") in references[mode]: + row = dict(row, source_partition=relative, source_sha256=source_hashes[str(source.resolve())]) + if "base_unit_code" in native: + row["base_unit_code"] = native["base_unit_code"] + data["records"][mode].append(row) + selected.append(deepcopy(row)) + # Keep only name membership and already requested rows, never all cell pads. + if known: + old_names = {row["name"] for row in selected} + selected.extend(row for row in known["selected"] if row["name"] not in old_names) + partitions[relative] = {"names": {row["name"] for row in native["records"]}, + "selected": selected, "run": deepcopy(run)} + # Remove unrelated full-library stdout only after selected records are durable. + persist() + (log / "stdout.txt").unlink() + run["stdout_retained"] = False + write_json(log / "run.json", run) + partitions[relative]["run"] = deepcopy(run) + persist() + except (OSError, ValueError) as error: + data["errors"].append({"partition": relative, "reason": str(error)}) + persist() + if source_hashes != _hashes(_library_sources(project)): + raise ValueError("Library changed during export; run a complete new attempt") + data["complete"] = not data["errors"] + data["records_sha256"] = _digest(data["records"]) + write_json(data_path, data) + missing, ambiguous = {}, {} + for mode in references: + counts = {name: sum(row["name"] == name for row in data["records"][mode]) for name in references[mode]} + missing[mode] = sorted(name for name, count in counts.items() if count == 0) + ambiguous[mode] = sorted(name for name, count in counts.items() if count > 1) + index = {"library": project["library"], "fingerprint": fingerprint, "shared_data": str(data_path), + "request": request, "missing": missing, "ambiguous": ambiguous, "errors": data["errors"], + "coverage_limits": data["coverage_limits"], "shared_data_sha256": sha256(data_path)} + destination.mkdir(parents=True, exist_ok=True) + index_path = destination / "工程引用与数据索引.json" + write_json(index_path, index) + item["outputs"] = [str(index_path), str(data_path)] + item["provenance"].update(library_fingerprint=fingerprint, library_source_hashes=source_hashes, + output_files=[_file_info(p) for p in item["outputs"]]) + if data["errors"] or any(missing.values()) or any(ambiguous.values()): + item.update(status="failed", reason="Partial library coverage: missing/ambiguous names or failed partitions; see index") + else: + item.update(status="success", reason="Used part/cell records read from fingerprinted shared library") + + +def _validate_native(native, mode): + if native.get("mode") != mode or native.get("count") != len(native.get("records", [])): + raise ValueError("Native enumeration count/mode mismatch") + if any(not isinstance(row.get("name"), str) or not row["name"] for row in native["records"]): + raise ValueError("Native getter returned invalid object name") + def visit(value): + if isinstance(value, dict): + if type(value.get("location_hr")) is int and 0 <= value["location_hr"] < 0x80000000: + point = value.get("xy_raw") + if not isinstance(point, list) or len(point) != 2 or any(type(c) is not int for c in point): + raise ValueError("Native getter returned invalid coordinate pointer/data") + for key, child in value.items(): + if key == "hr" or key.endswith("_hr"): + if type(child) is not int or child < 0 or child >= 0x80000000: + raise ValueError("Native getter failed: " + key) + if key == "value" and child is None: + raise ValueError("Native getter returned null value") + visit(child) + elif isinstance(value, list): + for child in value: + visit(child) + visit(native) diff --git a/mentorexport/report.py b/mentorexport/report.py new file mode 100644 index 0000000..7d55e80 --- /dev/null +++ b/mentorexport/report.py @@ -0,0 +1,72 @@ +"""Offline HTML summaries that link to unchanged, separately sourced exports.""" +from collections import Counter +from html import escape +from pathlib import Path +import os +from urllib.parse import quote + +LABELS = {"success": "成功", "partial": "部分成功", "failed": "失败", + "unavailable": "不可用", "cancelled": "已取消", "running": "执行中", "pending": "待执行"} +STYLE = """body{font:15px/1.65 'Segoe UI','Microsoft YaHei',sans-serif;background:#f4f6f9;color:#243246;margin:32px auto;max-width:1150px;padding:0 24px} +table{border-collapse:collapse;width:100%;background:white;margin:16px 0}th,td{padding:10px 14px;border:1px solid #dde3ec;text-align:left;vertical-align:top}th{background:#eaf0f8} +a{color:#1756a9;overflow-wrap:anywhere}.success{color:#137146}.failed{color:#b42318}.partial,.unavailable{color:#925600}code{background:#e9edf4;padding:2px 5px}small{color:#5c6a7d}.card{background:white;border:1px solid #dde3ec;border-radius:10px;padding:18px;margin:16px 0}""" + + +def link(path, base, label=None): + path, base = Path(path).resolve(), Path(base).resolve() + try: + href = quote(os.path.relpath(path, base).replace("\\", "/"), safe="/") + except ValueError: + href = path.as_uri() + return f'{escape(str(label or path.name))}' + + +def page(title, content): + return f'{escape(title)}

{escape(title)}

{content}' + + +def write_report(batch, record): + batch = Path(batch) + batch.mkdir(parents=True, exist_ok=True) + rows = [] + counts = Counter(row["status"] for row in record.get("projects", [])) + summary = " ".join(f"{LABELS.get(status, status)} {count}" for status, count in counts.items()) + for row in record.get("projects", []): + project = row["project"] + folder = Path(row["folder"]) + folder.mkdir(parents=True, exist_ok=True) + result = row.get("result", {}) + items = [] + for item in result.get("items", []): + outputs = "
".join(link(path, folder) for path in item.get("outputs", [])) + origin = item.get("provenance", {}) + tool = origin.get("tool") or origin.get("executable") or origin.get("backend") or item["key"] + if isinstance(tool, dict): + tool = Path(tool.get("path") or "").name or item["key"] + items.append(f'{escape(item["key"])}{escape(str(tool))}' + f'{LABELS.get(item["status"], escape(item["status"]))}' + f'{escape(str(item.get("reason", "")))}{outputs}') + limits = "".join("
  • " + escape(str(value)) + "
  • " for value in result.get("coverage_limits", [])) + discovery = result.get("snapshot_discovery", {}) + snapshot_names = "、".join(discovery.get("names", [])) or "未取得" + details = (f'
    状态:{LABELS.get(row["status"], row["status"])}
    ' + f'来源:{escape(str(project["path"]))}
    ' + f'根块:{escape(str(project.get("root_block", "")))} 快照:{escape(str(project.get("snapshot", "")))}
    ' + f'数据库快照名称(仅记录):{escape(snapshot_names)}
    ' + f'{escape(str(result.get("reason", "")))}
    ' + '

    各工具和模式的输出分别保留;同名字段可能具有不同来源。导出成功不等于工程电气正确性校验通过。

    ' + '' + "".join(items) + '
    导出项来源状态说明产物
    ' + + ('

    覆盖限制

      ' + limits + '
    ' if limits else '') + + link(folder / "export.json", folder, "工程原始记录 JSON") + + " " + link(folder / "90_运行日志", folder, "运行日志")) + (folder / "工程说明.html").write_text(page(project["name"], details), encoding="utf-8") + rows.append(f'{link(folder / "工程说明.html", batch, project["name"])}' + f'{LABELS.get(row["status"], escape(row["status"]))}' + f'{escape(str(result.get("reason", "")))}{escape(str(project["path"]))}') + issues = "".join(f'
  • {escape(str(p.get("path", "")))}:{escape(str(p.get("reason", "")))}
  • ' for p in record.get("problems", [])) + content = (f'
    {escape(summary or "没有可执行工程")}
    批次状态:{escape(record.get("state", ""))}
    ' + '

    默认读取已保存的原理图;不同工具的字段和覆盖范围分别记录。点击工程名查看逐项结果。

    ' + '' + "".join(rows) + '
    工程结果说明源文件
    ' + + ('

    扫描问题

      ' + issues + '
    ' if issues else '') + + link(batch / "batch.json", batch, "批次记录 JSON")) + (batch / "导出汇总.html").write_text(page("Mentor 原理图批量导出", content), encoding="utf-8") diff --git a/packaging/accept_portable.py b/packaging/accept_portable.py new file mode 100644 index 0000000..dcaa208 --- /dev/null +++ b/packaging/accept_portable.py @@ -0,0 +1,94 @@ +"""Exercise a relocated release with no system Python environment or PATH.""" +from pathlib import Path +import hashlib +import json +import os +import shutil +import subprocess +import sys +import time + +ROOT = Path(__file__).resolve().parent.parent +ACCEPTANCE = ROOT / ("build/release-acceptance-" + time.strftime("%Y%m%d-%H%M%S")) + + +def digest(path): + return hashlib.file_digest(path.open("rb"), "sha256").hexdigest() + + +def main(package): + package = Path(package).resolve() + destination = ACCEPTANCE / "中文 空格 便携工具" / package.name + if destination.exists(): + raise ValueError("Acceptance destination already exists; preserve previous evidence") + shutil.copytree(package, destination) + inputs = ACCEPTANCE / "input" + fixture_list = json.loads((ROOT / "build/acceptance/inputs.json").read_text(encoding="utf-8")) + first = inputs / "普通工程" + second = inputs + for index in range(6): + second /= f"长路径目录{index}_" + "中文路径" * 8 + for fixture, target in zip(fixture_list, (first, second)): + shutil.copytree(Path(fixture["path"]).parent, target) + prjs = list(inputs.rglob("*.prj")) + assert len(prjs) == 2 and max(len(str(path)) for path in prjs) > 260 + before = {str(path): digest(path) for path in inputs.rglob("*") if path.is_file()} + environment = dict(os.environ, PYTHONHOME=r"Z:\invalid-python", PYTHONPATH=r"Z:\invalid-packages", + PYTHONIOENCODING="utf-8", PATH=os.environ.get("SystemRoot", r"C:\Windows") + r"\System32") + evidence = {"package": str(package), "relocated": str(destination), "source_path_lengths": [len(str(p)) for p in prjs], + "environment": {key: environment[key] for key in ("PYTHONHOME", "PYTHONPATH", "PATH")}, "runs": []} + cmd = str(Path(os.environ.get("SystemRoot", r"C:\Windows")) / "System32/cmd.exe") + + def run(key, arguments, stdin=None): + started = time.monotonic() + command = '""' + str(destination / "导出.cmd") + '" ' + subprocess.list2cmdline(arguments) + '"' + # cmd parses quotes itself; list2cmdline escaping the /c body breaks its outer quotes. + process = subprocess.run(subprocess.list2cmdline([cmd]) + " /d /s /c " + command, input=stdin, env=environment, + cwd=Path(os.environ.get("SystemRoot", r"C:\Windows")) / "Temp", + capture_output=True, encoding="utf-8", errors="replace", timeout=1200, + creationflags=subprocess.CREATE_NO_WINDOW) + (ACCEPTANCE / (key + ".stdout.txt")).write_text(process.stdout, encoding="utf-8") + (ACCEPTANCE / (key + ".stderr.txt")).write_text(process.stderr, encoding="utf-8") + evidence["runs"].append({"key": key, "arguments": arguments, "exit_code": process.returncode, + "seconds": round(time.monotonic() - started, 3)}) + (ACCEPTANCE / "acceptance.json").write_text(json.dumps(evidence, ensure_ascii=False, indent=2), encoding="utf-8") + print(key, process.returncode, flush=True) + if process.returncode: + print(process.stdout, process.stderr, flush=True) + raise RuntimeError("Acceptance command failed: " + key) + return process.stdout + + diagnostic = json.loads(run("check", ["--check", "--json"])) + assert Path(diagnostic["python"]) == destination / "runtime/python.exe" + # Drive the actual no-argument wizard: input, output, confirmation, exit menu. + output = ACCEPTANCE / "导出结果" + run("wizard-export", [], f"{inputs}\n{output}\nY\n\n") + batches = sorted(output.glob("批次_*/batch.json")) + assert len(batches) == 1 + record = json.loads(batches[0].read_text(encoding="utf-8")) + assert record["exit_code"] == 0 and len(record["projects"]) == 2 + for row in record["projects"]: + result = row["result"] + assert row["status"] == "success" and len(result["items"]) == 11 + assert all(item["status"] == "success" for item in result["items"]) + assert result["source_unchanged"] is True + assert result["snapshot_discovery"]["status"] == "success" + for item in result["items"]: + assert item["provenance"]["snapshot"] == row["project"]["snapshot"] + assert all(Path(path).is_file() for path in item["outputs"]) + run("retry", ["--retry", str(batches[0].parent), "--yes"]) + retry_path = sorted(output.glob("批次_*/batch.json"))[-1] + retry = json.loads(retry_path.read_text(encoding="utf-8")) + assert all(item["provenance"]["reused"] for row in retry["projects"] for item in row["result"]["items"]) + assert before == {str(path): digest(path) for path in inputs.rglob("*") if path.is_file()} + manifest = json.loads((destination / "package-manifest.json").read_text(encoding="utf-8")) + assert all(digest(destination / name) == info["sha256"] for name, info in manifest["files"].items()) + evidence.update(status="passed", first_batch=str(batches[0].parent), retry_batch=str(retry_path.parent), + verified_package_files=len(manifest["files"]), source_files_unchanged=len(before), + projects=2, successful_export_items=22, reused_items=22) + (ACCEPTANCE / "acceptance.json").write_text(json.dumps(evidence, ensure_ascii=False, indent=2), encoding="utf-8") + print(json.dumps(evidence, ensure_ascii=False, indent=2), flush=True) + + +if __name__ == "__main__": + main(sys.argv[1]) diff --git a/packaging/build_portable.py b/packaging/build_portable.py new file mode 100644 index 0000000..262d0eb --- /dev/null +++ b/packaging/build_portable.py @@ -0,0 +1,126 @@ +"""Build an offline, relocatable folder with official embedded Python and pywin32.""" +from pathlib import Path +import argparse +import hashlib +import json +import os +import shutil +import subprocess +import sys +import urllib.request +import zipfile + +ROOT = Path(__file__).resolve().parent.parent +sys.path.insert(0, str(ROOT)) +from mentorexport.core import sha256, write_json + +PYTHON_VERSION = "3.12.10" +PYWIN32_VERSION = "312" + + +def download(url, target, expected=None): + target.parent.mkdir(parents=True, exist_ok=True) + if not target.exists() or (expected and sha256(target) != expected): + temporary = target.with_suffix(target.suffix + ".download") + with urllib.request.urlopen(url, timeout=60) as source, temporary.open("wb") as stream: + shutil.copyfileobj(source, stream) + os.replace(temporary, target) + if expected and sha256(target) != expected: + raise ValueError("Downloaded package checksum mismatch: " + str(target)) + return target + + +def extract(archive, destination): + destination.mkdir(parents=True, exist_ok=True) + with zipfile.ZipFile(archive) as package: + if package.testzip() is not None: + raise ValueError("Damaged archive: " + str(archive)) + for entry in package.infolist(): + if not (destination / entry.filename).resolve().is_relative_to(destination.resolve()): + raise ValueError("Archive member escapes target") + package.extractall(destination) + + +def prepare_runtime(): + cache = ROOT / "build/downloads" + python_zip = download( + f"https://www.python.org/ftp/python/{PYTHON_VERSION}/python-{PYTHON_VERSION}-embed-amd64.zip", + cache / f"python-{PYTHON_VERSION}-embed-amd64.zip") + with urllib.request.urlopen(f"https://pypi.org/pypi/pywin32/{PYWIN32_VERSION}/json", timeout=30) as response: + metadata = json.load(response) + wheel_name = f"pywin32-{PYWIN32_VERSION}-cp312-cp312-win_amd64.whl" + wheel_info = next(row for row in metadata["urls"] if row["filename"] == wheel_name) + wheel = download(wheel_info["url"], cache / wheel_name, wheel_info["digests"]["sha256"]) + runtime = ROOT / "build/runtime" + if not (runtime / "python.exe").is_file(): + extract(python_zip, runtime) + else: + with zipfile.ZipFile(python_zip) as package: + expected_python = hashlib.sha256(package.read("python.exe")).hexdigest() + if sha256(runtime / "python.exe") != expected_python: + raise ValueError("Runtime build cache is damaged; preserve it and use a fresh build directory") + if not (runtime / f"Lib/site-packages/pywin32-{PYWIN32_VERSION}.dist-info/METADATA").is_file(): + extract(wheel, runtime / "Lib/site-packages") + pth = "python312.zip\n.\nLib/site-packages\nLib/site-packages/win32\nLib/site-packages/win32/lib\nimport site\n" + pth_file = runtime / "python312._pth" + if not pth_file.is_file() or pth_file.read_text(encoding="utf-8") != pth: + pth_file.write_text(pth, encoding="utf-8") + return runtime, { + "python": {"version": PYTHON_VERSION, "architecture": "amd64", "archive_sha256": sha256(python_zip), + "source": f"https://www.python.org/ftp/python/{PYTHON_VERSION}/"}, + "pywin32": {"version": PYWIN32_VERSION, "wheel_sha256": sha256(wheel), "filename": wheel.name}, + "user_installation_required": False, + } + + +def build(destination): + destination = Path(destination).resolve() + if destination.exists(): + raise ValueError("Choose a new output folder; existing package is preserved: " + str(destination)) + runtime, dependencies = prepare_runtime() + if not (ROOT / "helpers/native_read.exe").is_file(): + raise ValueError("Build the x86 library helper before packaging") + destination.mkdir(parents=True) + shutil.copytree(runtime, destination / "runtime", ignore=shutil.ignore_patterns("__pycache__", "*.pyc")) + shutil.copytree(ROOT / "mentorexport", destination / "mentorexport", ignore=shutil.ignore_patterns("__pycache__", "*.pyc")) + shutil.copytree(ROOT / "helpers", destination / "helpers", ignore=shutil.ignore_patterns("*.obj", "*.pdb", "__pycache__")) + for name in ("export.py", "导出.cmd", "README.md"): + shutil.copy2(ROOT / name, destination / name) + # CMD's UTF-8 parser can truncate LF-only lines after chcp; ship native CRLF. + launcher = destination / "导出.cmd" + launcher.write_bytes(launcher.read_bytes().replace(b"\r\n", b"\n").replace(b"\n", b"\r\n")) + (destination / "licenses").mkdir() + (destination / "licenses/THIRD_PARTY.md").write_text( + "# Runtime notices\n\nPython " + PYTHON_VERSION + + ": see runtime/LICENSE.txt (PSF and included component notices).\n\n" + "pywin32 " + PYWIN32_VERSION + + ": see runtime/Lib/site-packages/pywin32-" + PYWIN32_VERSION + + ".dist-info/ for upstream license and metadata.\n\n" + "Mentor/Siemens vendor programs are not included. They are located on the target machine.\n", + encoding="utf-8") + write_json(destination / "runtime-dependencies.json", dependencies) + files = {p.relative_to(destination).as_posix(): {"sha256": sha256(p), "bytes": p.stat().st_size} + for p in sorted(destination.rglob("*")) if p.is_file()} + write_json(destination / "package-manifest.json", {"schema": 1, "files": files}) + archive = destination.parent / (destination.name + ".zip") + with zipfile.ZipFile(archive, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=6) as package: + for path in sorted(destination.rglob("*")): + if path.is_file(): + package.write(path, arcname=(Path("MentorExport") / path.relative_to(destination)).as_posix()) + with zipfile.ZipFile(archive) as package: + assert package.testzip() is None + print(json.dumps({"folder": str(destination), "zip": str(archive), "bytes": archive.stat().st_size, + "files": len(files)}, ensure_ascii=False, indent=2)) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=Path) + parser.add_argument("--runtime-only", action="store_true") + args = parser.parse_args() + if args.runtime_only: + print(json.dumps(prepare_runtime()[1], ensure_ascii=False, indent=2)) + elif args.output: + build(args.output) + else: + parser.error("Specify --output or --runtime-only") diff --git a/tests/test_cli.py b/tests/test_cli.py new file mode 100644 index 0000000..df13803 --- /dev/null +++ b/tests/test_cli.py @@ -0,0 +1,71 @@ +from pathlib import Path +from threading import Event +import json + + +def test_batch_does_not_stop_after_one_project_failure(tmp_path): + from mentorexport.cli import run_batch + def exporter(project, installation, folder, shared, **options): + if project["name"] == "坏工程": + raise ValueError("无法读取数据库") + return {"status": "success", "items": [{"key": "ascii", "status": "success", "outputs": []}]} + projects = [{"name": name, "path": str(tmp_path / (name + ".prj"))} for name in ("坏工程", "好工程")] + batch, code = run_batch(projects, [], {}, tmp_path / "out", tmp_path, exporter=exporter) + state = json.loads((batch / "batch.json").read_text(encoding="utf-8")) + assert code == 1 and state["state"] == "complete" + assert [p["status"] for p in state["projects"]] == ["failed", "success"] + assert (batch / "导出汇总.html").is_file() + + +def test_pre_cancelled_batch_does_not_start_exporter(tmp_path): + from mentorexport.cli import run_batch + stop = Event() + stop.set() + def exporter(*args, **kwargs): + raise AssertionError("cancelled batch started native work") + batch, code = run_batch([{"name": "工程", "path": str(tmp_path / "a.prj")}], [], {}, + tmp_path / "out", tmp_path, stop_event=stop, exporter=exporter) + state = json.loads((batch / "batch.json").read_text(encoding="utf-8")) + assert code == 130 and state["projects"][0]["status"] == "cancelled" + assert (Path(state["projects"][0]["folder"]) / "export.json").is_file() + + +def test_report_escapes_project_names_and_failure_details(tmp_path): + from mentorexport.report import write_report + record = {"state": "complete", "projects": [ + {"project": {"name": "", "path": "a.prj"}, + "folder": str(tmp_path / "a"), "status": "failed", + "result": {"status": "failed", "reason": "", "items": []}}], "problems": []} + write_report(tmp_path, record) + html = (tmp_path / "导出汇总.html").read_text(encoding="utf-8") + assert "