From 3228c1a2e677d1ed73f83a0ef31d870e4227bac7 Mon Sep 17 00:00:00 2001 From: Agent Date: Thu, 28 May 2026 01:53:51 +0800 Subject: [PATCH] =?UTF-8?q?feat:=20PinMAP=E8=BD=ACPinList=20v1.2.0=20-=20?= =?UTF-8?q?=E6=96=B0=E5=A2=9EPinList=E8=BD=ACPinMAP=E5=8F=8D=E5=90=91?= =?UTF-8?q?=E8=BD=AC=E6=8D=A2=E5=8A=9F=E8=83=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Code/docs/QUICKSTART.md | 342 +++-- Code/docs/README.md | 252 +++- Code/docs/RELEASE.md | 192 +++ Code/docs/architecture-design.md | 1729 ++++++++++++++----------- Code/src/file_selector.py | 51 +- Code/src/main.py | 208 ++- Code/src/models.py | 29 + Code/src/pinlist_parser.py | 116 ++ Code/src/pinlist_validator.py | 112 ++ Code/src/pinmap_generator.py | 86 ++ Code/src/pinmap_layout.py | 143 ++ Code/src/template_reader.py | 233 ++++ Code/src/validator.py | 85 ++ Code/src/xlsx_writer.py | 296 +++++ Releases/pinmap-to-pinlist-v1.1.0.zip | Bin 0 -> 59814 bytes Releases/pinmap-to-pinlist-v1.2.0.zip | Bin 0 -> 47717 bytes Test/run_tests.py | 700 ++++++++++ Test/test_report.md | 184 ++- 18 files changed, 3781 insertions(+), 977 deletions(-) create mode 100644 Code/src/pinlist_parser.py create mode 100644 Code/src/pinlist_validator.py create mode 100644 Code/src/pinmap_generator.py create mode 100644 Code/src/pinmap_layout.py create mode 100644 Code/src/template_reader.py create mode 100644 Releases/pinmap-to-pinlist-v1.1.0.zip create mode 100644 Releases/pinmap-to-pinlist-v1.2.0.zip create mode 100644 Test/run_tests.py diff --git a/Code/docs/QUICKSTART.md b/Code/docs/QUICKSTART.md index 24e8ef5..c8fc41e 100644 --- a/Code/docs/QUICKSTART.md +++ b/Code/docs/QUICKSTART.md @@ -1,6 +1,6 @@ # 快速入门指南 -本文档帮助你快速上手 PinMAP → PinList 转换器。 +本文档帮助你快速上手 PinMAP ↔ PinList 双向转换器。 --- @@ -46,36 +46,57 @@ cd pinmap-to-pinlist/Code/src/ ### 第二步：运行转换 -#### 方式一：GUI 模式（推荐） +#### 方式一：交互式模式（推荐） ```bash python main.py ``` -弹出文件选择对话框，选择 `.xls` 或 `.xlsx` 文件即可。 +运行后显示方向选择菜单，选择 1 或 2： + +``` +请选择转换方向: + 1 — PinMAP → PinList + 2 — PinList → PinMAP + +请输入选项 (1/2): _ +``` #### 方式二：命令行模式 ```bash -python main.py /path/to/your/input.xlsx +# PinMAP → PinList（直接指定文件） +python main.py /path/to/your/PinMAP.xlsx + +# PinList → PinMAP（命令行模式默认走 MAP→List 方向） +# 如需 List→MAP，请使用交互式模式 ``` ### 第三步：查看输出 -转换完成后，在当前目录生成 `{原文件名}_PinList.xlsx`： +转换完成后，在当前目录生成输出文件： ``` -输入: QFP44_PinMAP.xlsx -输出: QFP44_PinMAP_PinList.xlsx +PinMAP → PinList: QFP44_PinMAP.xlsx → QFP44_PinMAP_PinList.xlsx +PinList → PinMAP: QFN20_PinList.xlsx → QFN20_PinList_PinMAP.xlsx ``` --- -## 使用示例 +## 方向一：PinMAP → PinList -### 示例 1：标准方形 PinMAP +将方形封装引脚布局图转换为线性引脚列表。 -**输入文件** `QFP44.xlsx`： +### 操作步骤 + +1. 运行 `python main.py`，选择方向 **1** +2. 选择 PinMAP 文件（`.xls` 或 `.xlsx`） +3. 等待转换完成 +4. 查看输出的 `_PinList.xlsx` 文件 + +### 使用示例 + +**输入文件** `QFP44.xlsx`（6×6 方形封装，8 个引脚）： ``` A B C D E F @@ -88,7 +109,7 @@ python main.py /path/to/your/input.xlsx 7 3 4 ``` -**运行命令**： +**运行**： ```bash python main.py QFP44.xlsx @@ -97,12 +118,20 @@ python main.py QFP44.xlsx **输出**： ``` +[INFO] 正在读取文件: QFP44.xlsx +[INFO] 文件读取完成，共 16 个非空单元格 +[INFO] 正在解析 PinMAP 结构... [INFO] 解析完成: 6x6 方形，共 8 个Pin [INFO] 封装信息: QFP-44 +[INFO] 正在验证数据... +[INFO] 验证通过 +[INFO] 正在生成 PinList... +[INFO] 正在写入输出文件: QFP44_PinList.xlsx -[SUCCESS] 转换完成！输出文件: QFP44_PinList.xlsx - - 封装信息: QFP-44 - - Pin数量: 8 +[SUCCESS] 转换完成！ + 输出文件: QFP44_PinList.xlsx + 封装信息: QFP-44 + Pin数量: 8 ``` **输出文件内容**： @@ -118,62 +147,7 @@ python main.py QFP44.xlsx 7 Pin6 6 ``` -### 示例 2：长方形 PinMAP - -**输入文件** `LQFP100.xlsx`（13 个引脚的长方形封装） - -```bash -python main.py LQFP100.xlsx -``` - -**输出**： - -``` -[INFO] 解析完成: 长方形结构，共 13 个Pin -[INFO] 封装信息: LQFP-100 - -[SUCCESS] 转换完成！输出文件: LQFP100_PinList.xlsx - - 封装信息: LQFP-100 - - Pin数量: 13 -``` - -### 示例 3：处理警告 - -当 PinMAP 中部分引脚缺少 PinName 时： - -``` -[INFO] 解析完成: 6x6 方形，共 8 个Pin -[INFO] 封装信息: QFP-44 - -[WARN] 发现 3 个警告: - - 检测到 3 个引脚缺少 PinName: 缺失引脚序号: [2, 3, 4]，将默认为 NC - -[SUCCESS] 转换完成！输出文件: QFP44_PinList.xlsx - - 封装信息: QFP-44 - - Pin数量: 8 -``` - -缺失 PinName 的引脚在输出中自动标记为 "NC"。 - -### 示例 4：处理错误 - -当 PinMAP 存在数据错误时： - -``` -[INFO] 解析完成: 6x6 方形，共 8 个Pin -[INFO] 封装信息: QFP-44 - -[ERROR] 发现 1 个错误: - - Pin序号不连续: 缺失的序号: [3] - -转换终止，请修正PinMAP文件后重试。 -``` - ---- - -## PinMAP 文件规范 - -### 格式要求 +### PinMAP 文件规范 | 要求 | 说明 | |------|------| @@ -192,7 +166,204 @@ python main.py LQFP100.xlsx 上边：序号在 (min_row, c)，PinName 在 (min_row+1, c) ``` -### 支持的输入格式 +--- + +## 方向二：PinList → PinMAP + +将线性引脚列表转换为方形封装引脚布局图。 + +### 操作步骤 + +1. 运行 `python main.py`，选择方向 **2** +2. 选择 PinList 文件（`.xls` 或 `.xlsx`） +3. **输入 PinMAP 行数**（至少 2） +4. **输入 PinMAP 列数**（至少 2） +5. 等待转换完成 +6. 查看输出的 `_PinMAP.xlsx` 文件 + +### 尺寸输入说明 + +PinMAP 的引脚分布在四条边上，总引脚数由网格尺寸决定： + +``` +总引脚数 = 2 × 行数 + 2 × 列数 − 4 +``` + +常见封装尺寸参考： + +| 封装类型 | 引脚数 | 推荐行数 | 推荐列数 | +|----------|--------|----------|----------| +| QFP-8 | 8 | 4 | 4 | +| QFP-16 | 16 | 6 | 6 | +| QFP-20 | 20 | 6 | 6 | +| QFP-24 | 24 | 8 | 6 | +| QFP-32 | 32 | 10 | 8 | +| QFP-44 | 44 | 12 | 10 | +| QFP-64 | 64 | 16 | 16 | +| QFP-100 | 100 | 26 | 26 | + +> **提示**：如果不确定尺寸，可以先用公式反推：`行数 + 列数 = (引脚数 + 4) / 2`，然后根据需要调整行和列的比例。 + +### 模板文件说明 + +PinList → PinMAP 转换时，程序会自动尝试从输入文件所在目录读取模板样式： + +- **模板来源**：程序会尝试解析与输入文件同名的 `.xlsx` 模板文件中的样式信息 +- **提取内容**：字体（名称、大小、粗体、斜体、颜色）、填充、边框、列宽、行高 +- **优雅降级**：如果模板不存在或解析失败，程序会自动使用默认样式，不影响转换流程 + +### 使用示例 + +**输入文件** `QFN20_PinList.xlsx`（20 个引脚）： + +``` + A B +1 QFN-20 +2 VCC 1 +3 GND 2 +4 IO0 3 +5 IO1 4 +6 IO2 5 +7 IO3 6 +8 IO4 7 +9 IO5 8 +10 IO6 9 +11 IO7 10 +12 NC 11 +13 NC 12 +14 NC 13 +15 NC 14 +16 NC 15 +17 NC 16 +18 NC 17 +19 NC 18 +20 NC 19 +21 NC 20 +``` + +**运行**： + +```bash +python main.py +# 选择方向: 2 (PinList → PinMAP) +# 选择文件: QFN20_PinList.xlsx +# 输入行数: 6 +# 输入列数: 6 +``` + +**输出**： + +``` +[INFO] PinMAP 尺寸: 6 行 × 6 列 +[INFO] 正在解析 PinList 文件: QFN20_PinList.xlsx +[INFO] 解析完成: 封装信息 'QFN-20', 共 20 个引脚 +[INFO] 正在验证数据... +[INFO] 验证通过 +[INFO] 正在生成 PinMAP 并写入: QFN20_PinList_PinMAP.xlsx + +[SUCCESS] 转换完成！ + 输出文件: QFN20_PinList_PinMAP.xlsx + 封装信息: QFN-20 + PinMAP 尺寸: 6×6 + Pin数量: 20 +``` + +**输出文件内容**（6×6 网格，20 个引脚）： + +``` + A B C D E F +1 QFN-20 IO8 IO7 +2 1 VCC IO6 IO5 +3 2 GND IO4 IO3 +4 3 IO0 IO2 IO1 +5 4 IO1 NC NC +6 20 19 18 17 16 +``` + +### 布局规则 + +引脚按**逆时针**分配到四条边（左上角为 1 脚）： + +``` +左边: 从上到下（rows 个引脚） +下边: 从左到右（cols − 1 个引脚） +右边: 从下到上（rows − 2 个引脚） +上边: 从右到左（cols − 1 个引脚） +``` + +PinName 与序号的相对位置： + +``` +左边：Name 在序号右侧 +下边：Name 在序号上方 +右边：Name 在序号左侧 +上边：Name 在序号下方 +``` + +--- + +## 使用示例汇总 + +### 示例 1：标准方形 PinMAP（MAP→List） + +**输入** `QFP44.xlsx`（6×6，8 Pin） + +```bash +python main.py QFP44.xlsx +``` + +**输出** `QFP44_PinList.xlsx`（A 列 PinName，B 列序号） + +### 示例 2：长方形 PinMAP（MAP→List） + +**输入** `LQFP100.xlsx`（长方形，13 Pin） + +```bash +python main.py LQFP100.xlsx +``` + +**输出** `LQFP100_PinList.xlsx` + +### 示例 3：标准 PinList（List→MAP） + +**输入** `QFN20_PinList.xlsx`（20 Pin） + +```bash +python main.py +# 选择 2，输入 6×6 +``` + +**输出** `QFN20_PinList_PinMAP.xlsx`（6×6 方形） + +### 示例 4：处理警告 + +当 PinMAP 中部分引脚缺少 PinName 时： + +``` +[WARN] 发现 3 个警告: + - 检测到 3 个引脚缺少 PinName: 缺失引脚序号: [2, 3, 4]，将默认为 NC + +[SUCCESS] 转换完成！ +``` + +缺失 PinName 的引脚在输出中自动标记为 "NC"。 + +### 示例 5：处理错误 + +当 PinList 引脚数与网格尺寸不匹配时： + +``` +[ERROR] 验证未通过，发现 1 个错误: + - Pin数量与网格周长不匹配: 网格 6×6 需要 20 个引脚，但 PinList 有 24 个 + +转换终止，请修正PinList文件或网格尺寸后重试。 +``` + +--- + +## 支持的格式 + +### 输入格式 | 格式 | 扩展名 | 支持情况 | |------|--------|----------| @@ -233,7 +404,7 @@ python main.py input.xlsx ### Q3: 提示 "A1 单元格为空，缺少封装信息" -**原因**：PinMAP 文件的 A1 单元格为空。 +**原因**：文件的 A1 单元格为空。 **解决**：在 Excel 中打开文件，在 A1 单元格填入封装信息（如 "QFP-44"），保存后重新转换。 @@ -241,21 +412,29 @@ python main.py input.xlsx **原因**：Pin 序号存在间隔（如 1, 2, 4, 5，缺少 3）。 -**解决**：检查 PinMAP 文件，补全缺失的引脚序号。 +**解决**：检查文件，补全缺失的引脚序号。 ### Q5: 提示 "Pin序号重复" **原因**：同一个 Pin 序号出现了多次。 -**解决**：检查 PinMAP 文件，修正重复的序号。 +**解决**：检查文件，修正重复的序号。 -### Q6: 警告 "检测到 N 个引脚缺少 PinName" +### Q6: 提示 "Pin数量与网格周长不匹配" + +**原因**：PinList 的引脚数与输入的 rows×cols 网格周长不一致。 + +**解决**： +- 检查引脚数量是否正确 +- 或调整网格尺寸，使 `2×rows + 2×cols − 4 = 引脚数` + +### Q7: 警告 "检测到 N 个引脚缺少 PinName" **说明**：这是警告而非错误，转换会继续进行。缺失的 PinName 会自动设为 "NC"。 **解决**（可选）：在 Excel 中补全缺失的 PinName，重新转换。 -### Q7: Linux 下没有弹出文件选择对话框 +### Q8: Linux 下没有弹出文件选择对话框 **说明**：Linux 无头环境（无显示器）不支持 tkinter GUI。 @@ -269,26 +448,31 @@ python main.py /path/to/input.xlsx sudo apt install python3-tk ``` -### Q8: 输出文件打不开 +### Q9: 输出文件打不开 **可能原因**：Excel 版本过旧（2003 及以下不支持 .xlsx）。 **解决**：使用 Excel 2007+ 或 WPS Office 打开输出文件。 -### Q9: 支持多大的 PinMAP？ +### Q10: 支持多大的 PinMAP？ **回答**：当前实现适合 < 1000 引脚的场景。典型 IC 封装引脚数在 8~200 之间，完全满足需求。 -### Q10: 能否批量转换多个文件？ +### Q11: 能否批量转换多个文件？ **回答**：当前版本一次处理一个文件。如需批量转换，可使用 shell 脚本： ```bash +# PinMAP → PinList for f in *.xlsx; do python main.py "$f" done ``` +### Q12: 命令行模式下如何执行 PinList → PinMAP？ + +**回答**：命令行模式下直接传入文件参数默认走 PinMAP → PinList 方向。如需执行 PinList → PinMAP，请使用交互式模式（不带参数运行），选择方向 2。 + --- ## 测试验证 diff --git a/Code/docs/README.md b/Code/docs/README.md index 567d213..9188fcb 100644 --- a/Code/docs/README.md +++ b/Code/docs/README.md @@ -1,15 +1,18 @@ -# PinMAP → PinList 转换器 +# PinMAP ↔ PinList 双向转换器 -将 Excel 格式的 **PinMAP** 文件（方形封装引脚布局图）自动转换为 **PinList** 格式（引脚序号列表），消除手动抄录的低效与错误风险。 +将 Excel 格式的 **PinMAP**（方形封装引脚布局图）与 **PinList**（引脚序号列表）互相转换，消除手动抄录的低效与错误风险。 + +- **PinMAP → PinList**：自动识别方形/长方形结构，逆时针提取引脚，生成线性列表 +- **PinList → PinMAP**：根据引脚列表和网格尺寸，自动计算布局并生成方形封装图 --- ## 项目简介 -在 IC 封装设计中，PinMAP 以方形/长方形矩阵形式展示引脚分布，而 PinList 则以线性列表形式提供引脚序号对照。本项目通过纯 Python 实现，自动完成从 PinMAP 到 PinList 的转换，支持 `.xls` 和 `.xlsx` 两种格式。 +在 IC 封装设计中，PinMAP 以方形/长方形矩阵形式展示引脚分布，而 PinList 则以线性列表形式提供引脚序号对照。本项目通过纯 Python 实现，自动完成 PinMAP 与 PinList 之间的双向转换，支持 `.xls` 和 `.xlsx` 两种格式。 -**版本**: v1.0.0 -**发布日期**: 2026-05-25 +**版本**: v1.2.0 +**发布日期**: 2026-05-28 **运行平台**: Windows（tkinter GUI）/ Linux（命令行回退） **技术栈**: Python 标准库，零第三方依赖 @@ -21,19 +24,30 @@ | 功能 | 说明 | |------|------| -| **PinMAP 解析** | 自动识别方形/长方形结构，沿四条边（左→下→右→上）逆时针提取引脚 | -| **数据验证** | 检测序号不连续、序号重复、PinName 缺失、A1 封装信息缺失 | -| **PinList 生成** | A 列 PinName，B 列 Pin 序号，按序号递增排序 | +| **PinMAP → PinList** | 自动识别方形/长方形结构，沿四条边（左→下→右→上）逆时针提取引脚，生成 PinList | +| **PinList → PinMAP** | 根据引脚列表和网格尺寸，自动计算布局并生成 PinMAP | +| **数据验证** | 双向验证：检测序号不连续、序号重复、PinName 缺失、A1 封装信息缺失、周长匹配 | +| **模板样式** | PinList → PinMAP 时自动读取模板文件的字体、填充、边框、列宽、行高等样式 | | **双格式支持** | 同时支持 `.xls`（BIFF8 引擎）和 `.xlsx`（OOXML 引擎） | | **双模式运行** | GUI 文件选择对话框 + 命令行参数模式 | ### 验证规则 +#### PinMAP → PinList 验证 + - **序号连续性**：Pin 序号必须为 1~N 连续整数，无间隔 - **序号唯一性**：每个 Pin 序号只能出现一次，无重复 - **PinName 完整性**：缺失 PinName 的引脚自动标记为 "NC"（警告级别，不中断流程） - **结构完整性**：方形区域至少 2×2，A1 单元格必须包含封装信息 +#### PinList → PinMAP 验证 + +- **序号连续性**：Pin 序号必须从 1 开始连续无缺失 +- **序号唯一性**：每个 Pin 序号只能出现一次，无重复 +- **周长匹配**：Pin 总数 = 2×rows + 2×cols − 4（与网格周长一致） +- **PinName 完整性**：缺失 PinName 的引脚自动标记为 "NC"（警告级别） +- **非 4 倍数提示**：Pin 数量不是 4 的倍数时提示（信息级别） + --- ## 技术栈 @@ -49,13 +63,22 @@ | `xlsx_writer.py` | XLSX 写入引擎（OOXML 构建） | `zipfile`, `xml.etree.ElementTree` | | `file_selector.py` | 文件选择对话框 | `tkinter.filedialog` | | `pinmap_parser.py` | PinMAP 结构解析 | 纯 Python | -| `validator.py` | 数据验证 | `collections.Counter` | +| `pinmap_layout.py` | PinMAP 布局计算 | 纯 Python | +| `pinmap_generator.py` | PinMAP 生成与输出 | 纯 Python | +| `pinlist_parser.py` | PinList 文件解析 | 纯 Python | +| `pinlist_validator.py` | PinList 数据验证 | `collections.Counter` | | `pinlist_generator.py` | PinList 生成 | 纯 Python | +| `validator.py` | PinMAP 数据验证 | `collections.Counter` | +| `template_reader.py` | 模板样式提取 | `zipfile`, `xml.etree.ElementTree` | +| `models.py` | 数据模型 | `dataclasses` | +| `utils.py` | 工具函数 | 纯 Python | ### 核心技术亮点 - **BIFF8 手动解析**：从零实现 OLE2 复合文档 + BIFF8 记录流解析，支持 SST、LABELSST、NUMBER、FORMULA、RK、MULRK、LABEL 等记录类型 - **OOXML 手动构建**：不使用 openpyxl/xlrd，纯手工构建 `[Content_Types].xml`、`workbook.xml`、`sharedStrings.xml`、`sheet1.xml` 等 OOXML 结构 +- **布局算法**：根据网格尺寸自动计算四边引脚分配，支持任意 rows×cols 的矩形封装 +- **模板样式引擎**：从 xlsx 文件中提取字体、填充、边框、列宽、行高等样式并应用到输出文件 - **模块化架构**：解析 → 验证 → 生成 → 输出，各模块职责清晰，接口契约明确 --- @@ -68,8 +91,32 @@ - Windows 环境（GUI 模式需要 tkinter） - Linux/Mac 环境（仅命令行模式） +### 交互式模式（推荐） + +```bash +python main.py +``` + +运行后显示转换方向选择菜单： + +``` +============================================================ + PinMAP ↔ PinList 双向转换器 + 支持 PinMAP→PinList 与 PinList→PinMAP 互转 + 支持.xls和.xlsx格式，输出.xlsx格式 +============================================================ + +请选择转换方向: + 1 — PinMAP → PinList + 2 — PinList → PinMAP + +请输入选项 (1/2): +``` + ### 命令行模式 +#### PinMAP → PinList + ```bash # 基本用法 python main.py input.xlsx @@ -80,16 +127,34 @@ python main.py input.xls # 输出文件自动命名为 input_PinList.xlsx ``` +#### PinList → PinMAP + +```bash +# 命令行模式：需提供文件路径 +python main.py input_PinList.xlsx + +# 运行后需要手动输入 PinMAP 尺寸： +# 请输入 PinMAP 行数: 6 +# 请输入 PinMAP 列数: 6 +# 输出文件自动命名为 input_PinList_PinMAP.xlsx +``` + +> **注意**：命令行模式下直接传入文件参数时，默认走 PinMAP → PinList 方向。如需 PinList → PinMAP，请使用交互式模式（不带参数运行）选择方向 2。 + ### GUI 模式 ```bash -# 不带参数运行，弹出文件选择对话框 +# 不带参数运行，弹出方向选择 + 文件选择对话框 python main.py ``` -在对话框中选择 `.xls` 或 `.xlsx` 文件，点击"打开"即可开始转换。 +选择方向后，在对话框中选择 `.xls` 或 `.xlsx` 文件，点击"打开"即可开始转换。 -### 输出示例 +--- + +## 使用示例 + +### 示例 1：PinMAP → PinList 输入 PinMAP（方形封装）： @@ -104,7 +169,32 @@ python main.py 7 3 4 ``` -输出 PinList： +**运行命令**： + +```bash +python main.py QFP44.xlsx +``` + +**输出**： + +``` +[INFO] 正在读取文件: QFP44.xlsx +[INFO] 文件读取完成，共 16 个非空单元格 +[INFO] 正在解析 PinMAP 结构... +[INFO] 解析完成: 6x6 方形，共 8 个Pin +[INFO] 封装信息: QFP-44 +[INFO] 正在验证数据... +[INFO] 验证通过 +[INFO] 正在生成 PinList... +[INFO] 正在写入输出文件: QFP44_PinList.xlsx + +[SUCCESS] 转换完成！ + 输出文件: QFP44_PinList.xlsx + 封装信息: QFP-44 + Pin数量: 8 +``` + +**输出 PinList**： ``` A B @@ -117,6 +207,88 @@ python main.py 7 Pin6 6 ``` +### 示例 2：PinList → PinMAP + +输入 PinList： + +``` + A B +1 QFN-20 +2 VCC 1 +3 GND 2 +4 IO0 3 +5 IO1 4 +6 IO2 5 +7 IO3 6 +8 IO4 7 +9 IO5 8 +10 IO6 9 +11 IO7 10 +12 NC 11 +13 NC 12 +14 NC 13 +15 NC 14 +16 NC 15 +17 NC 16 +18 NC 17 +19 NC 18 +20 NC 19 +21 NC 20 +``` + +**运行命令**： + +```bash +python main.py +# 选择方向: 2 (PinList → PinMAP) +# 选择文件: QFN20_PinList.xlsx +# 输入行数: 6 +# 输入列数: 6 +``` + +**输出**： + +``` +[INFO] 正在解析 PinList 文件: QFN20_PinList.xlsx +[INFO] 解析完成: 封装信息 'QFN-20', 共 20 个引脚 +[INFO] 正在验证数据... +[INFO] 验证通过 +[INFO] 正在生成 PinMAP 并写入: QFN20_PinList_PinMAP.xlsx + +[SUCCESS] 转换完成！ + 输出文件: QFN20_PinList_PinMAP.xlsx + 封装信息: QFN-20 + PinMAP 尺寸: 6×6 + Pin数量: 20 +``` + +**输出 PinMAP**（6×6 网格，20 个引脚）： + +``` + A B C D E F +1 QFN-20 IO8 IO7 +2 1 VCC IO6 IO5 +3 2 GND IO4 IO3 +4 3 IO0 IO2 IO1 +5 4 IO1 NC NC +6 20 19 18 17 16 +``` + +### 示例 3：尺寸不匹配错误 + +当 PinList 引脚数与网格周长不匹配时： + +``` +[ERROR] 验证未通过，发现 1 个错误: + - Pin数量与网格周长不匹配: 网格 6×6 需要 20 个引脚，但 PinList 有 24 个 + +转换终止，请修正PinList文件或网格尺寸后重试。 +``` + +### 示例 4：使用模板样式 + +PinList → PinMAP 转换时，程序会自动尝试从同目录下的模板文件读取样式（字体、边框、列宽等），使输出 PinMAP 的格式与目标模板保持一致。 + --- ## 项目结构 @@ -125,14 +297,19 @@ python main.py pinmap-to-pinlist/ ├── Code/ │ ├── src/ -│ │ ├── main.py # 主入口：流程编排 +│ │ ├── main.py # 主入口：流程编排 + 双向转换 │ │ ├── file_selector.py # 文件选择（GUI + 命令行回退） │ │ ├── xls_reader.py # XLS (BIFF8) 读取引擎 │ │ ├── xlsx_reader.py # XLSX 读取引擎 -│ │ ├── xlsx_writer.py # XLSX 写入引擎 +│ │ ├── xlsx_writer.py # XLSX 写入引擎（含样式支持） │ │ ├── pinmap_parser.py # PinMAP 结构解析 -│ │ ├── validator.py # 数据验证 -│ │ ├── pinlist_generator.py # PinList 生成 +│ │ ├── pinmap_layout.py # PinMAP 布局计算（List→MAP） +│ │ ├── pinmap_generator.py # PinMAP 生成与输出（List→MAP） +│ │ ├── pinlist_parser.py # PinList 文件解析（List→MAP） +│ │ ├── pinlist_validator.py # PinList 数据验证（List→MAP） +│ │ ├── pinlist_generator.py # PinList 生成（MAP→List） +│ │ ├── validator.py # PinMAP 数据验证（MAP→List） +│ │ ├── template_reader.py # 模板样式提取（List→MAP） │ │ ├── models.py # 数据模型 │ │ ├── utils.py # 工具函数 │ │ └── test_pinmap.py # 单元测试 @@ -192,7 +369,7 @@ pinmap-to-pinlist/ ## 解析算法说明 -### PinMAP 结构 +### PinMAP → PinList：逆时针提取 PinMAP 以方形/长方形矩阵展示引脚分布： @@ -205,8 +382,6 @@ row 3 [PinName] [ ] [PinName] row 4 [13] [12] [11] [10] ← 下边 Pin 序号 ``` -### 逆时针提取规则 - 引脚沿四条边**逆时针**提取： 1. **左边**：从上到下 @@ -216,23 +391,52 @@ row 4 [13] [12] [11] [10] ← 下边 Pin 序号 角点单元格只计数一次（按单元格位置去重）。 -### PinList 输出规则 +### PinList → PinMAP：布局计算 + +根据用户输入的 rows × cols 网格尺寸，将引脚列表按**逆时针**分配到四条边： + +``` +总引脚数 = 2 × rows + 2 × cols − 4 + +左边: rows 个引脚（从上到下） +下边: cols − 1 个引脚（从左到右） +右边: rows − 2 个引脚（从下到上） +上边: cols − 1 个引脚（从右到左） +``` + +PinName 与序号的相对位置： + +``` +左边：序号在 (r, 0)，PinName 在 (r, 1) → Name 在序号右侧 +下边：序号在 (rows, c)，PinName 在 (rows-1, c) → Name 在序号上方 +右边：序号在 (r, cols)，PinName 在 (r, cols-1) → Name 在序号左侧 +上边：序号在 (1, c)，PinName 在 (2, c) → Name 在序号下方 +``` + +### PinList 输出规则（MAP→List） - A1 单元格：封装信息（从 PinMAP 的 A1 复制） - A 列：PinName（缺失时自动设为 "NC"） - B 列：Pin 序号 - 按 Pin 序号递增排序 +### PinMAP 输出规则（List→MAP） + +- A1 单元格：封装信息（从 PinList 的 A1 读取） +- 四边分布：序号 + PinName 按布局算法填入网格 +- 缺失 PinName 自动设为 "NC" +- 可选：应用模板样式（字体、边框、列宽、行高） + --- ## 错误处理 | 级别 | 类型 | 行为 | |------|------|------| -| `[FATAL]` | 文件格式错误 / 结构错误 | 终止处理，显示错误信息 | -| `[ERROR]` | 数据验证错误（重复/不连续） | 终止处理，显示详细错误 | +| `[FATAL]` | 文件格式错误 / 结构错误 / 布局计算失败 | 终止处理，显示错误信息 | +| `[ERROR]` | 数据验证错误（重复/不连续/周长不匹配） | 终止处理，显示详细错误 | | `[WARN]` | PinName 缺失 | 提示警告，自动设为 "NC"，继续处理 | -| `[INFO]` | 解析进度信息 | 仅显示，不影响流程 | +| `[INFO]` | 解析进度信息 / 非 4 倍数提示 | 仅显示，不影响流程 | | `[SUCCESS]` | 转换完成 | 显示输出文件路径和统计信息 | --- diff --git a/Code/docs/RELEASE.md b/Code/docs/RELEASE.md index 3945d84..163dcf2 100644 --- a/Code/docs/RELEASE.md +++ b/Code/docs/RELEASE.md @@ -2,6 +2,198 @@ --- +## v1.2.0 — 2026-05-28 + +### ✨ 新增 PinList → PinMAP 反向转换 + +v1.2.0 为项目增加了完整的反向转换能力，PinMAP ↔ PinList 现在可以双向互转。 + +--- + +### 新增功能 + +#### PinList → PinMAP 转换 +- **PinList 解析**：从 Excel 文件中读取 PinName（A 列）和 Pin 序号（B 列） +- **布局计算**：根据用户输入的行数和列数，自动计算四边引脚分配 +- **逆时针分配**：左上角为 1 脚，沿左边→下边→右边→上边逆时针排列 +- **PinName 定位**：自动计算 PinName 与序号的相对位置（右/上/左/下） +- **周长验证**：检查引脚总数是否匹配 `2×rows + 2×cols − 4` +- **优雅降级**：缺失 PinName 自动设为 "NC" + +#### 模板样式引擎 +- **样式提取**：从模板 xlsx 文件中提取字体、填充、边框、列宽、行高 +- **样式应用**：将模板样式应用到生成的 PinMAP 输出文件 +- **优雅降级**：模板不存在或解析失败时自动使用默认样式 + +#### 交互式方向选择 +- **启动菜单**：运行 `python main.py` 显示方向选择（1: MAP→List / 2: List→MAP） +- **尺寸输入**：List→MAP 模式需要输入 PinMAP 的行数和列数 +- **文件选择**：根据方向自动切换文件选择器标题和提示 + +#### 数据验证增强 +- **PinList 验证**：序号连续性、序号唯一性、周长匹配、PinName 完整性 +- **非 4 倍数提示**：Pin 数量不是 4 的倍数时提示（信息级别） + +--- + +### 新增模块 + +| 模块 | 代码量 | 说明 | +|------|--------|------| +| `pinlist_parser.py` | ~80 行 | PinList 文件解析（A/B 列读取 + 排序） | +| `pinlist_validator.py` | ~90 行 | PinList 数据验证（连续性/唯一性/周长匹配） | +| `pinmap_generator.py` | ~70 行 | PinMAP 生成与输出（布局应用 + 样式） | +| `pinmap_layout.py` | ~100 行 | PinMAP 布局计算（四边分配 + 坐标计算） | +| `template_reader.py` | ~170 行 | 模板样式提取（fonts/fills/borders/cols/rows） | + +### 更新模块 + +| 模块 | 变更说明 | +|------|----------| +| `main.py` | 增加 `run_list_to_map()` 流程 + 方向选择菜单 | +| `file_selector.py` | 增加 `mode` 参数，支持 "map_to_list" / "list_to_map" | +| `models.py` | 新增 `PinListEntry`、`EdgePins`、`PinMAPLayout`、`LayoutError` | +| `xlsx_writer.py` | 增加 `write_xlsx_with_style()` 支持模板样式写入 | +| `validator.py` | 新增 `PinMapValidator` 类，统一验证接口 | + +--- + +### 技术实现 + +#### 布局算法 + +``` +总引脚数 = 2 × rows + 2 × cols − 4 + +左边: rows 个引脚（从上到下） +下边: cols − 1 个引脚（从左到右） +右边: rows − 2 个引脚（从下到上） +上边: cols − 1 个引脚（从右到左） +``` + +#### 坐标映射 + +``` +左边: 序号 (r, 0) → Name (r, 1) 右侧 +下边: 序号 (rows, c) → Name (rows-1, c) 上方 +右边: 序号 (r, cols) → Name (r, cols-1) 左侧 +上边: 序号 (1, c) → Name (2, c) 下方 +``` + +#### 模板样式提取 + +``` +xl/styles.xml: + ├── fonts: name, size, bold, italic, color + ├── fills: pattern_type, fg_color + ├── borders: top, bottom, left, right (style + color) + └── cellXfs: numFmtId, fontId, fillId, borderId, alignment + +xl/worksheets/sheet1.xml: + ├── cols: column width (min, max, width) + └── sheetData: row height +``` + +--- + +### 测试覆盖 + +#### 单元测试（8 个用例） + +| 用例 | 测试内容 | 结果 | +|------|----------|------| +| `test_4x4_parse` | 4×4 方形 PinMAP 解析 | ✅ | +| `test_4x4_validate` | 4×4 方形验证 | ✅ | +| `test_missing_names_warning` | PinName 缺失警告 | ✅ | +| `test_duplicate_numbers` | 序号重复检测 | ✅ | +| `test_gap_in_numbers` | 序号不连续检测 | ✅ | +| `test_empty_cells` | 空单元格处理 | ✅ | +| `test_no_pins` | 无引脚数据检测 | ✅ | +| `test_12pin_square` | 12 引脚方形解析 | ✅ | + +#### 集成测试（6 个用例） + +| 用例 | 输入文件 | 测试内容 | 结果 | +|------|----------|----------|------| +| TC001 | `sample_4x4.xlsx` | 标准 4×4 转换（8 Pin） | ✅ | +| TC002 | `sample_rect.xlsx` | 长方形转换（13 Pin） | ✅ | +| TC003 | `error_gap.xlsx` | 序号不连续检测 | ✅ | +| TC004 | `error_dup.xlsx` | 序号重复检测 | ✅ | +| TC005 | `warning_missing.xlsx` | PinName 缺失警告 | ✅ | +| TC006 | `error_empty_a1.xlsx` | A1 为空检测 | ✅ | + +**测试通过率**：100%（14/14） + +--- + +### 已知问题 + +无 + +--- + +### 限制 + +| 限制项 | 说明 | +|--------|------| +| 引脚数量 | 建议 < 1000 引脚（典型封装 < 200 引脚，无压力） | +| 输入格式 | 仅支持 `.xls` 和 `.xlsx`，不支持 CSV/其他格式 | +| 输出格式 | 仅输出 `.xlsx`，不支持 `.xls` | +| 工作表 | 仅处理第一个工作表 | +| 公式单元格 | 仅读取公式的计算结果，不保留公式本身 | +| 命令行方向 | 命令行模式直接传入文件默认走 MAP→List，List→MAP 需交互式选择 | + +--- + +### 未来计划 + +#### v1.3.0 — 格式增强（规划中） + +- [ ] 支持 `.xls` 格式输出 +- [ ] 保留原始 Excel 的字体和格式（MAP→List 方向） +- [ ] 支持多工作表选择 + +#### v1.4.0 — 功能扩展（规划中） + +- [ ] 批量转换（拖拽多个文件） +- [ ] CSV 格式输出 +- [ ] PinMAP 结构可视化预览 + +#### v2.0.0 — 架构升级（远期规划） + +- [ ] 支持更多封装类型（BGA、QFN 等） +- [ ] 插件式解析器架构 +- [ ] Web 界面 + +--- + +### 升级指南 + +**首次使用**：直接运行即可，无需升级。 + +**从 v1.0.0 升级**：替换 `Code/src/` 目录下所有文件。 + +**从 v1.1.0 升级**：替换 `Code/src/` 目录下所有文件。 + +--- + +### 贡献者 + +- 架构设计：Script Architect +- 编码实现：Coding Agent × 3 +- 测试验证：QA Agent +- 文档编写：Doc Gen Agent + +--- + +### 获取帮助 + +- 查看 `QUICKSTART.md` 了解使用方法 +- 查看 `architecture-design.md` 了解技术细节 +- 查看 `Test/test_report.md` 了解测试详情 + +--- + ## v1.0.0 — 2026-05-25 ### 🎉 首次发布 diff --git a/Code/docs/architecture-design.md b/Code/docs/architecture-design.md index 3e38c89..36ef152 100644 --- a/Code/docs/architecture-design.md +++ b/Code/docs/architecture-design.md @@ -1,9 +1,10 @@ -# PinMAP → PinList 转换器 — 全局架构设计 +# PinMAP ↔ PinList 双向转换器 — 全局架构设计 -> **版本**: v1.0 -> **日期**: 2026-05-25 +> **版本**: v2.0 +> **日期**: 2026-05-28 > **架构师**: 脚本架构师 (Script Architect) -> **状态**: 待审批 +> **状态**: 待审批 +> **变更**: 新增 PinList → PinMAP 反向转换 + 模板格式支持 --- @@ -11,13 +12,17 @@ ### 1.1 背景 -将 Excel 格式的 **PinMAP** 文件（方形封装引脚布局图）自动转换为 **PinList** 格式（引脚序号列表），消除手动抄录的低效与错误风险。 +将 Excel 格式的 **PinMAP** 文件（方形封装引脚布局图）与 **PinList** 格式（引脚序号列表）进行**双向自动转换**，消除手动抄录的低效与错误风险。 + +- **PinMAP → PinList**（已有）：方形布局图 → 扁平引脚列表 +- **PinList → PinMAP**（新增）：扁平引脚列表 → 方形布局图 ### 1.2 核心规则 - PinMAP 为方形/长方形结构，引脚沿四条边分布，左上角为 1 脚，**逆时针**排序 -- 左上角 = 1 脚，右上角 = 上边最后一个脚，右下角 = 下边最后一个脚，左下角 = 左边最后一个脚 +- 四条边遍历顺序：左→下→右→上（counter-clockwise） - 四个角点被相邻两边共享（不重复计数） +- 总 Pin 数 = 2 × width + 2 × height − 4 ### 1.3 约束 @@ -28,833 +33,1091 @@ | 输入格式 | `.xls`（必须支持）、`.xlsx`（优先支持） | | 输出格式 | `.xlsx` 仅 | | 交互方式 | 命令行 + 文件选择对话框 | +| 模板 | 可选，根目录 `PinMAP-Template.xlsx` | --- -## 2. 技术选型 +## 2. 技术可行性评估 -### 2.1 为什么不用 openpyxl / xlrd？ +### 2.1 PinList → PinMAP 反向转换 -项目明确要求 **无第三方依赖**，因此必须使用 Python 标准库自行实现 Excel 读写。 +**可行性：✅ 完全可行** -### 2.2 XLS 读取 — BIFF8 二进制解析 +| 子任务 | 技术可行性 | 说明 | +|--------|-----------|------| +| PinList 读取与解析 | ✅ 低难度 | 复用现有 xls_reader/xlsx_reader，解析 A/B 两列即可 | +| Pin 数据验证 | ✅ 低难度 | 连续性、唯一性检查逻辑与现有 validator 类似 | +| 尺寸输入 | ✅ 低难度 | 命令行 `input()` 交互，输入行数/列数 | +| PinMAP 布局计算 | ✅ 中难度 | 核心算法：根据 width/height 将 Pin 分配到四条边 | +| PinMAP 生成与输出 | ✅ 中难度 | 需要增强 xlsx_writer 支持模板样式 | +| 模板检测与读取 | ✅ 中难度 | 需新增 xlsx style 读取能力（styles.xml 解析） | -`.xls` 是 Microsoft **BIFF8** 二进制格式（复合文档 OLE2 容器）。 +### 2.2 关键技术难点 -**实现策略**： +#### 难点 1：PinMAP 布局分配算法 + +**问题**：给定 PinList（N 个 Pin，已按序号 1..N 排序）和尺寸 (rows, cols)，如何将 Pin 分配到四条边？ + +**公式**（逆时针，左上角为 1 脚）： ``` -1. 使用 struct 模块解析 OLE2 复合文档头 -2. 解析 FAT（文件分配表）定位 MiniFAT 和目录流 -3. 定位 Workbook 流，读取 BIFF8 记录序列 -4. 关键记录类型： - - 0x0009 (BOF) → 块起始标记 - - 0x00FD (LABELSST) → 共享字符串表中的文本单元格 - - 0x0006 (FORMULA) → 公式/数值单元格 - - 0x0203 (NUMBER) → 数值单元格 - - 0x000C (RK) → RK 数值（压缩整数/浮点） - - 0x000D (RString) → 内联字符串 - - 0x00FC (STRING) → 字符串结果 - - 0x0034 (SST) → 全局共享字符串表 - - 0x0042 (BOUNDSHEET) → 工作表信息 -5. 提取每个单元格的 (行, 列, 值) 三元组 +总 Pin 数 N = 2 × cols + 2 × rows − 4 + +边分配（按遍历顺序）： + 左边 (left) = rows 个 Pin → Pin 1..rows + 下边 (bottom) = cols − 1 个 Pin → Pin (rows+1)..(rows+cols−1) + 右边 (right) = rows − 2 个 Pin → Pin (rows+cols)..(rows+2×cols−3) + 上边 (top) = cols − 1 个 Pin → Pin (rows+2×cols−2)..N + +验证：rows + (cols−1) + (rows−2) + (cols−1) = 2×rows + 2×cols − 4 = N ✓ ``` -**复杂度评估**：中等。BIFF8 是固定长度记录流，struct 解析直接。需处理 Unicode 编码（BIFF8 默认 UTF-16LE，部分兼容 ASCII）。 +**示例**：4×8 网格（rows=4, cols=8, N=20） -### 2.3 XLSX 读取 — ZIP + XML - -`.xlsx` 本质是 ZIP 压缩包，内部为 Office Open XML (OOXML)。 - -**实现策略**： - -```python -import zipfile -import xml.etree.ElementTree as ET - -1. zipfile.ZipFile 打开 .xlsx -2. 读取 [Content_Types].xml 确认结构 -3. 读取 xl/workbook.xml 获取工作表关系 -4. 读取 xl/worksheets/sheet1.xml 获取单元格数据 -5. 读取 xl/sharedStrings.xml 获取共享字符串表 -6. 解析单元格坐标（如 "A2" → 列A行2）和值类型 +``` +左边：Pin 1-4 (4个) +下边：Pin 5-12 (8个) +右边：Pin 13-15 (3个) +上边：Pin 16-20 (5个) +总计：4+8+3+5 = 20 ✓ ``` -**复杂度评估**：低。zipfile 和 xml.etree 均为标准库，XML 结构规范清晰。 +**非 4 倍数处理**：提示用户 "Pin 数量 {N} 不是 4 的倍数，四条边将不均匀分布"，不影响转换。 -### 2.4 XLSX 写入 — ZIP + XML 生成 +#### 难点 2：模板样式读取 -**实现策略**： +**问题**：从零实现的 xlsx_reader 目前只读取单元格值，不读取样式（字体、边框、背景色等）。PinMAP 输出需要参考模板的单元格样式。 -```python -import zipfile -import xml.etree.ElementTree as ET -from io import BytesIO +**方案**： +1. 新增 `template_reader.py` 模块，专门解析 `xl/styles.xml` +2. 提取关键样式信息：字体、边框、填充色、对齐方式 +3. 在 `pinmap_generator.py` 中应用模板样式到输出文件 +4. 模板不存在时，使用默认样式（无边框、默认字体） -1. 构建 OOXML 目录结构： - [Content_Types].xml - _rels/.rels - xl/workbook.xml - xl/worksheets/sheet1.xml - xl/sharedStrings.xml - xl/_rels/workbook.xml.rels +**OOXML styles.xml 结构**： -2. 使用 zipfile.ZipFile 写入（ZIP_DEFLATED） - -3. 关键 XML 构建： - - sharedStrings.xml: 所有唯一字符串的 SST - - sheet1.xml: 单元格坐标 + si (SST index) 引用 - - workbook.xml: 工作表引用 - - [Content_Types].xml: MIME 类型声明 +```xml + + + + + ... + ... + + + + ``` -**复杂度评估**：低。XML 结构固定，模板化生成即可。 +**复杂度评估**：中等。需解析 XML 结构，提取 cellXfs（单元格格式）与 fonts/borders/fills 的关联关系。 -### 2.5 技术选型总结 +#### 难点 3：双向交互流程 -| 操作 | 格式 | 标准库模块 | 难度 | -|------|------|-----------|------| -| 读取 | xls | `struct` + 手动 OLE2/BIFF8 解析 | 中 | -| 读取 | xlsx | `zipfile` + `xml.etree.ElementTree` | 低 | -| 写入 | xlsx | `zipfile` + `xml.etree.ElementTree` | 低 | -| 文件选择 | — | `tkinter.filedialog` | 低 | +**问题**：main.py 需要支持两种转换方向，交互流程不同。 + +**方案**：启动时让用户选择方向，然后进入对应的流程。保持与现有 PinMAP→PinList 一致的交互风格（Banner → 文件选择 → 处理 → 结果摘要）。 --- ## 3. 模块划分 +### 3.1 现有模块（PinMAP → PinList 方向） + +``` +Code/src/ +├── main.py # 入口：流程编排（需修改） +├── file_selector.py # 文件选择（需修改） +├── xls_reader.py # XLS 解析引擎（不变） +├── xlsx_reader.py # XLSX 解析引擎（不变） +├── pinmap_parser.py # PinMAP 结构解析（不变） +├── validator.py # 数据验证（需修改） +├── pinlist_generator.py # PinList 生成（不变） +├── xlsx_writer.py # XLSX 输出引擎（需修改） +├── models.py # 数据模型（需修改） +└── utils.py # 工具函数（不变） +``` + +### 3.2 新增模块（PinList → PinMAP 方向） + +| 模块 | 文件 | 职责 | +|------|------|------| +| **PinList 解析器** | `pinlist_parser.py` | 读取 PinList xlsx，解析 A1 封装信息 + A/B 列 PinName/序号 | +| **PinList 验证器** | `pinlist_validator.py` | 验证 Pin 序号连续性、唯一性、与周长匹配 | +| **PinMAP 布局计算** | `pinmap_layout.py` | 根据尺寸将 Pin 分配到四条边，计算单元格坐标 | +| **PinMAP 生成器** | `pinmap_generator.py` | 组装 PinMAP 单元格数据，应用模板样式 | +| **模板读取器** | `template_reader.py` | 读取 PinMAP-Template.xlsx 的样式信息 | + +### 3.3 修改后完整目录结构 + ``` pinmap-to-pinlist/ ├── Code/ │ ├── src/ -│ │ ├── main.py # 入口：流程编排 -│ │ ├── file_selector.py # 模块1：文件选择 -│ │ ├── xls_reader.py # 模块2a：XLS 解析引擎 -│ │ ├── xlsx_reader.py # 模块2b：XLSX 解析引擎 -│ │ ├── pinmap_parser.py # 模块3：PinMAP 结构解析 -│ │ ├── validator.py # 模块4：数据验证 -│ │ ├── pinlist_generator.py # 模块5：PinList 生成 -│ │ └── xlsx_writer.py # 模块6：XLSX 输出引擎 +│ │ ├── main.py # ✏️ 修改：双向选择 + 双流程 +│ │ ├── file_selector.py # ✏️ 修改：支持两种文件类型过滤 +│ │ ├── models.py # ✏️ 修改：新增 PinList 输入模型 +│ │ ├── validator.py # ✏️ 修改：新增 PinList 验证函数 +│ │ ├── xlsx_writer.py # ✏️ 修改：支持样式写入 +│ │ │ +│ │ ├── xls_reader.py # （不变） +│ │ ├── xlsx_reader.py # （不变） +│ │ ├── pinmap_parser.py # （不变） +│ │ ├── pinlist_generator.py # （不变） +│ │ ├── utils.py # （不变） +│ │ │ +│ │ ├── pinlist_parser.py # 🆕 PinList 读取与解析 +│ │ ├── pinlist_validator.py # 🆕 PinList 数据验证 +│ │ ├── pinmap_layout.py # 🆕 PinMAP 布局计算 +│ │ ├── pinmap_generator.py # 🆕 PinMAP 生成与输出 +│ │ └── template_reader.py # 🆕 模板样式读取 │ └── docs/ -│ └── architecture-design.md +│ ├── architecture-design.md # ✏️ 更新 +│ └── modification-assessment.md ├── Test/ +│ └── fixtures/ +│ ├── sample_4x4.xlsx # 现有 PinMAP 测试 +│ ├── sample_rect.xlsx +│ ├── sample_pinlist.xlsx # 🆕 PinList 测试 +│ └── PinMAP-Template.xlsx # 🆕 模板文件（可选） +├── run.bat # （不变） └── Releases/ ``` -### 3.1 模块职责 +--- -#### 模块1：`file_selector` — 文件选择 +## 4. 模块详细设计 + +### 4.1 新增模块：`pinlist_parser.py` + +**职责**：读取 PinList 格式的 xlsx 文件，解析封装信息和引脚数据。 ```python -def select_file() -> str | None: - """弹出文件选择对话框，返回选中文件路径或 None（取消）""" -``` +"""PinList parser — reads a flat pin list from an Excel file.""" -- 使用 `tkinter.filedialog.askopenfilename` -- 文件类型过滤：`*.xls;*.xlsx` -- 无 GUI 环境时回退到命令行参数 +from dataclasses import dataclass -#### 模块2a：`xls_reader` — XLS 解析引擎 +@dataclass +class PinListEntry: + """A single pin entry from the PinList.""" + number: int # Pin 序号（B 列） + name: str # PinName（A 列，可能为空） -```python -class XLSReader: - def __init__(self, filepath: str) - def read_all_cells(self) -> dict[tuple[int, int], str]: - """返回 {(row, col): value} 字典，行列从 0 开始""" - def close(self) -``` -**内部结构**： +class PinListParser: + """Parse a PinList Excel file.""" -``` -XLSReader -├── OLE2Parser → 解析复合文档，定位 Workbook 流 -├── BIFF8Parser → 解析 BIFF8 记录流 -│ ├── SSTParser → 共享字符串表 -│ └── CellParser → 单元格记录 -└── CellMap → 组装为 (row, col) → value 映射 -``` + def __init__(self, filepath: str): + self._filepath = filepath -#### 模块2b：`xlsx_reader` — XLSX 解析引擎 - -```python -class XLSXReader: - def __init__(self, filepath: str) - def read_all_cells(self) -> dict[tuple[int, int], str]: - """返回 {(row, col): value} 字典，行列从 0 开始""" - def close(self) -``` - -**内部结构**： - -``` -XLSXReader -├── ZipExtractor → 解压 .xlsx 到内存 -├── SharedStrings → 解析 sharedStrings.xml -├── SheetParser → 解析 sheet1.xml -│ ├── CoordParser → 列字母转索引 (A→0, B→1, ...) -│ └── CellParser → 提取单元格值 -└── CellMap → 组装为 (row, col) → value 映射 -``` - -#### 模块3：`pinmap_parser` — PinMAP 结构解析 - -```python -def parse_pinmap(cells: dict[tuple[int, int], str]) -> PinMAP: - """ - 解析步骤： - 1. 排除 (0,0) 后扫描非空单元格，确定方形边界 - 2. 提取 A1 封装信息 - 3. 沿四条边提取引脚序号（边界单元格）和 PinName（相邻内侧单元格） - 4. 逆时针遍历（左→下→右→上），按单元格位置去重（角点共享） - 5. 返回 PinMAP 对象 - """ -``` - -**解析算法**： - -``` -Step 1: 确定方形边界 - - 排除 (0,0)（封装信息单元格） - - 扫描所有非空单元格，找到最小/最大行号和列号 - - width = max_col - min_col + 1 - - height = max_row - min_row + 1 - - 验证：width >= 2 且 height >= 2 - -Step 2: 提取 A1 封装信息 - - cells[(0, 0)] → package_info - -Step 3: 构建 PinName 查找表 - 每条边的 PinName 位于序号单元格的"内侧相邻"位置： - 左边：序号在 (r, min_col)， Name 在 (r, min_col+1) - 下边：序号在 (max_row, c)， Name 在 (max_row-1, c) - 右边：序号在 (r, max_col)， Name 在 (r, max_col-1) - 上边：序号在 (min_row, c)， Name 在 (min_row+1, c) - -Step 4: 逆时针遍历四条边（按单元格位置去重） - 4a. 左边：从上到下 (row: min_row → max_row, col: min_col) - 4b. 下边：从左到右 (row: max_row, col: min_col+1 → max_col) - 4c. 右边：从下到上 (row: max_row-1 → min_row, col: max_col) - 4d. 上边：从右到左 (row: min_row, col: max_col-1 → min_col) - - 角点去重：按 (row, col) 单元格位置去重，而非按 Pin 序号。 - 这样如果两个不同单元格恰好有相同序号，validator 能检测到。 - -Step 5: 组装 Pin 列表 - 按逆时针顺序：Pin1(左上角) → Pin2 → ... → PinN -``` - -#### 模块4：`validator` — 数据验证 - -```python -def validate_pinmap(pinmap: PinMAP) -> ValidationResult: - """ - 验证项： - 1. Pin序号唯一性（无重复） - 2. Pin序号连续性（1..N 无间隔） - 3. PinName 缺失检测（warning，默认 NC） - 4. 方形结构完整性（width/height >= 2） - """ -``` - -#### 模块5：`pinlist_generator` — PinList 生成 - -```python -class PinListGenerator: - def __init__(self, pinmap: PinMAP, validation: ValidationResult) - def generate(self) -> PinList: + def parse(self) -> tuple[str, list[PinListEntry]]: """ - 生成规则： - - A1 = 封装信息 - - A列 = PinName - - B列 = Pin序号 - - 按 Pin序号 递增排序 + 解析 PinList 文件。 + + Returns + ------- + (package_info, entries) + package_info: A1 单元格的封装信息 + entries: 按 Pin 序号排序的引脚列表 + + Raises + ------ + StructureError + A1 为空、A/B 列无数据、序号非整数等 + """ + # 1. 读取文件（复用 xlsx_reader / xls_reader） + # 2. 提取 A1 封装信息 + # 3. 解析 A 列 (PinName) 和 B 列 (Pin序号) + # 4. 按 Pin 序号排序 + # 5. 返回 (package_info, entries) +``` + +**解析规则**： +- A1 单元格 = 封装信息（与 PinMAP 方向一致） +- A 列（从 A2 开始）= PinName +- B 列（从 B2 开始）= Pin 序号 +- 读取到第一个空行为止 +- Pin 序号可能不是按顺序排列的（需要在 validator 中检查） + +### 4.2 新增模块：`pinlist_validator.py` + +**职责**：验证 PinList 数据的完整性和正确性。 + +```python +"""PinList validator — checks pin data integrity.""" + +from models import ValidationResult, ValidationError + + +def validate_pinlist( + entries: list[PinListEntry], + rows: int, + cols: int, +) -> ValidationResult: + """ + 验证 PinList 数据。 + + 检查项： + 1. Pin 序号从 1 开始连续无缺失 + 2. Pin 序号无重复 + 3. Pin 总数 = 2×rows + 2×cols − 4（周长匹配） + 4. Pin 缺少 PinName 时默认为 NC（warning） + 5. Pin 数量不是 4 的倍数时提示（info） + + Parameters + ---------- + entries : list[PinListEntry] + 已按序号排序的引脚列表 + rows : int + 用户输入的 PinMAP 行数 + cols : int + 用户输入的 PinMAP 列数 + + Returns + ------- + ValidationResult + """ +``` + +**验证逻辑**： + +```python +# 1. 连续性检查 +numbers = sorted(e.number for e in entries) +expected = list(range(1, len(numbers) + 1)) +if numbers != expected: + missing = set(expected) - set(numbers) + errors.append(f"Pin序号不连续，缺失: {sorted(missing)}") + +# 2. 唯一性检查 +if len(numbers) != len(set(numbers)): + errors.append("Pin序号存在重复") + +# 3. 周长匹配 +expected_total = 2 * rows + 2 * cols - 4 +if len(entries) != expected_total: + errors.append( + f"Pin数量 ({len(entries)}) 与网格周长 ({expected_total}) 不匹配" + ) + +# 4. 缺失 PinName（warning） +missing_names = [e for e in entries if not e.name or not e.name.strip()] +if missing_names: + warnings.append(f"{len(missing_names)} 个引脚缺少 PinName，将默认为 NC") + +# 5. 非 4 倍数提示（info） +if len(entries) % 4 != 0: + infos.append(f"Pin数量 ({len(entries)}) 不是 4 的倍数，四条边将不均匀分布") +``` + +### 4.3 新增模块：`pinmap_layout.py` + +**职责**：根据 PinMAP 尺寸和 PinList 数据，计算每条边的 Pin 分布和单元格坐标。 + +```python +"""PinMAP layout calculator — distributes pins to four edges.""" + +from dataclasses import dataclass +from typing import NamedTuple + +class CellRef(NamedTuple): + """Excel cell reference (row, col), 0-based.""" + row: int + col: int + + +@dataclass +class EdgePins: + """Pins assigned to one edge of the PinMAP.""" + edge: str # "left" | "bottom" | "right" | "top" + pins: list[tuple[int, str]] # [(number, name), ...] + cells: list[CellRef] # 对应的单元格坐标 + + +def calculate_layout( + entries: list[PinListEntry], + rows: int, + cols: int, +) -> dict[str, EdgePins]: + """ + 计算 PinMAP 布局。 + + 逆时针分配（左上角为 1 脚）： + 左边 → 下边 → 右边 → 上边 + + Parameters + ---------- + entries : list[PinListEntry] + 已按序号排序的引脚列表 + rows : int + PinMAP 行数 + cols : int + PinMAP 列数 + + Returns + ------- + dict[str, EdgePins] + {"left": ..., "bottom": ..., "right": ..., "top": ...} + + Raises + ------ + StructureError + 尺寸无效（rows < 2 或 cols < 2） + """ +``` + +**布局算法**： + +```python +def calculate_layout(entries, rows, cols): + """ + 网格坐标体系（0-based）： + + 假设方形区域从 (1, 0) 开始（Excel 的 A2）， + 方形区域：行 [1..rows]，列 [0..cols-1] + + 四条边的单元格坐标： + + 左边 (left): 序号在 (r, 0), Name 在 (r, 1) 其中 r ∈ [1, rows] + 下边 (bottom): 序号在 (rows, c), Name 在 (rows-1, c) 其中 c ∈ [1, cols-1] + 右边 (right): 序号在 (r, cols-1), Name 在 (r, cols-2) 其中 r ∈ [rows-1, 2] + 上边 (top): 序号在 (1, c), Name 在 (2, c) 其中 c ∈ [cols-2, 1] + + Pin 分配（按逆时针遍历顺序）： + 左边: Pin 1..rows → rows 个 + 下边: Pin (rows+1)..(rows+cols-1) → cols-1 个 + 右边: Pin (rows+cols)..(rows+2*cols-3) → rows-2 个 + 上边: Pin (rows+2*cols-2)..N → cols-1 个 + """ +``` + +**示例**：4×8 网格 + +``` +左边 (4个): Pin 1-4 + 序号: (1,0)=1, (2,0)=2, (3,0)=3, (4,0)=4 + Name: (1,1), (2,1), (3,1), (4,1) + +下边 (8个): Pin 5-12 + 序号: (4,1)=5, (4,2)=6, ..., (4,8)=12 + Name: (3,1), (3,2), ..., (3,8) + +右边 (3个): Pin 13-15 + 序号: (3,8)=13, (2,8)=14, (1,8)=15 + Name: (3,7), (2,7), (1,7) + +上边 (5个): Pin 16-20 + 序号: (1,7)=16, (1,6)=17, ..., (1,3)=20 + Name: (2,7), (2,6), ..., (2,3) +``` + +### 4.4 新增模块：`pinmap_generator.py` + +**职责**：根据布局计算结果，生成 PinMAP 的单元格数据字典，并写入 xlsx 文件。 + +```python +"""PinMAP generator — builds PinMAP cell data and writes to xlsx.""" + +from pinmap_layout import calculate_layout, EdgePins +from template_reader import TemplateStyle +from xlsx_writer import write_xlsx_with_style + + +def generate_pinmap( + entries: list[PinListEntry], + rows: int, + cols: int, + package_info: str, + template_style: TemplateStyle | None = None, + output_path: str | None = None, +) -> dict[str, str]: + """ + 生成 PinMAP 布局并写入文件。 + + Parameters + ---------- + entries : list[PinListEntry] + PinList 数据 + rows : int + PinMAP 行数 + cols : int + PinMAP 列数 + package_info : str + 封装信息（写入 A1） + template_style : TemplateStyle | None + 模板样式（可选） + output_path : str | None + 输出文件路径 + + Returns + ------- + dict[str, str] + 单元格数据字典 {"A1": "封装", "A2": "1", "B2": "Pin1", ...} + """ + # 1. 计算布局 + layout = calculate_layout(entries, rows, cols) + + # 2. 构建单元格数据 + data = {"A1": package_info} + for edge_name, edge in layout.items(): + for (pin_num, pin_name), cell in zip(edge.pins, edge.cells): + data[f"{cell_ref(cell)}"] = str(pin_num) + name_cell = get_name_cell(cell, edge_name) + data[f"{cell_ref(name_cell)}"] = pin_name or "NC" + + # 3. 写入文件（应用模板样式） + if output_path: + write_xlsx_with_style(data, output_path, template_style) + + return data +``` + +### 4.5 新增模块：`template_reader.py` + +**职责**：读取 PinMAP-Template.xlsx 的样式信息。 + +```python +"""Template reader — extracts cell styles from a template xlsx file.""" + +from dataclasses import dataclass, field +from typing import Optional + + +@dataclass +class FontStyle: + """Font style.""" + name: str = "Calibri" + size: float = 11.0 + bold: bool = False + italic: bool = False + color: str = "000000" + + +@dataclass +class BorderStyle: + """Border style for a cell.""" + top: str = "none" # none | thin | medium | thick + bottom: str = "none" + left: str = "none" + right: str = "none" + color: str = "000000" + + +@dataclass +class FillStyle: + """Cell fill style.""" + pattern_type: str = "none" # none | solid | gray125 + fg_color: str = "" + + +@dataclass +class AlignmentStyle: + """Cell alignment.""" + horizontal: str = "center" # left | center | right + vertical: str = "center" + + +@dataclass +class TemplateStyle: + """Complete style extracted from template.""" + fonts: list[FontStyle] = field(default_factory=list) + borders: list[BorderStyle] = field(default_factory=list) + fills: list[FillStyle] = field(default_factory=list) + cell_xfs: list[dict] = field(default_factory=list) # xf index → style mapping + column_widths: dict[int, float] = field(default_factory=dict) + row_heights: dict[int, float] = field(default_factory=dict) + + +class TemplateReader: + """Read styles from a template xlsx file.""" + + def __init__(self, filepath: str): + self._filepath = filepath + + def read_styles(self) -> TemplateStyle: + """ + 读取模板文件的样式信息。 + + 解析 xl/styles.xml 中的： + - fonts, fills, borders, cellXfs + - 列宽和行高（从 sheetData 读取） + + Returns + ------- + TemplateStyle """ ``` -#### 模块6：`xlsx_writer` — XLSX 输出引擎 +**实现要点**： +- 复用 `xlsx_reader.py` 的 ZIP 解压和 XML 解析能力 +- 新增解析 `xl/styles.xml` 的逻辑 +- 提取 `cellXfs` 中每个 xf 索引对应的 fontId/borderId/fillId +- 列宽从 `` 元素读取，行高从 `` 元素的 `ht` 属性读取 -```python -class XLSXWriter: - def __init__(self) - def write_pinlist(self, pinlist: PinList, output_path: str) -``` +### 4.6 修改模块：`main.py` -### 3.2 模块依赖关系 - -``` -main.py - ├── file_selector.py - ├── xls_reader.py ──┐ - ├── xlsx_reader.py ─┤ - │ ▼ - │ pinmap_parser.py - │ ▼ - │ validator.py - │ ▼ - │ pinlist_generator.py - │ ▼ - └─────────── xlsx_writer.py -``` - ---- - -## 4. 数据结构设计 - -### 4.1 Pin（引脚） - -```python -@dataclass -class Pin: - number: int # 引脚序号（1-based） - name: str # 引脚名称（缺失时默认为 "NC"） - edge: str # 所在边: "top" | "right" | "bottom" | "left" - position_on_edge: int # 在该边上的位置（0-based） -``` - -### 4.2 PinMAP（引脚映射图） - -```python -@dataclass -class PinMAP: - package_info: str # A1 单元格封装信息 - pins: list[Pin] # 所有引脚（按序号排序） - width: int # 方形宽度（列数） - height: int # 方形高度（行数） - grid_origin: tuple[int, int] # (row, col) 方形左上角 - raw_cells: dict[tuple[int, int], str] # 原始单元格数据（调试用） -``` - -### 4.3 PinList（引脚列表） - -```python -@dataclass -class PinList: - package_info: str # 输出 A1 单元格 - rows: list[tuple[str, int]] # [(PinName, Pin序号), ...] 按序号排序 -``` - -### 4.4 ValidationResult（验证结果） - -```python -@dataclass -class ValidationError: - level: str # "error" | "warning" - message: str # 错误描述 - details: str # 详细信息（如重复的序号、缺失的Pin等） - -@dataclass -class ValidationResult: - is_valid: bool - errors: list[ValidationError] - warnings: list[ValidationError] -``` - -### 4.5 内部：单元格坐标体系 - -``` -统一使用 (row, col) 元组，0-based： - - row 0 = Excel 第1行 - - col 0 = Excel A列 - - A1 = (0, 0) - - A2 = (1, 0) - - C2 = (1, 2) - - B4 = (3, 1) -``` - ---- - -## 5. 异常处理策略 - -### 5.1 异常分类 - -| 级别 | 类型 | 处理方式 | 示例 | -|------|------|---------|------| -| FATAL | 文件格式错误 | 终止 + 错误信息 | 非Excel文件、BIFF损坏 | -| FATAL | 结构错误 | 终止 + 错误信息 | 非方形、缺少A1、无边数据 | -| ERROR | 数据错误 | 终止 + 详细错误 | 序号不连续、序号重复 | -| WARN | 数据警告 | 提示 + 继续 | PinName缺失（默认NC） | -| INFO | 信息提示 | 仅显示 | 转换完成、统计信息 | - -### 5.2 自定义异常层次 - -```python -class PinMapError(Exception): - """基类异常""" - -class FileFormatError(PinMapError): - """文件格式错误（非xls/xlsx、文件损坏）""" - -class StructureError(PinMapError): - """PinMAP结构错误（非方形、缺少必要数据）""" - -class ValidationError(PinMapError): - """数据验证错误（序号不连续、重复）""" - -class WarningLevel(PinMapError): - """警告级别（PinName缺失等，可继续处理）""" -``` - -### 5.3 错误信息规范 - -``` -[级别] 错误类别: 具体描述 - 详细信息: ... - 建议操作: ... -``` - -示例： -``` -[ERROR] 序号不连续: 检测到序号间断 - 预期: 1,2,3,4,5,6 实际: 1,2,3,5,6 - 缺失序号: 4 - 建议: 检查PinMAP文件中是否有遗漏的引脚 - -[WARN] PinName缺失: 检测到 3 个引脚缺少PinName - 缺失引脚: Pin 7, Pin 12, Pin 18 - 处理: 已自动设为 "NC" -``` - -### 5.4 主流程异常处理 +**修改内容**：支持双向转换，启动时选择方向。 ```python def main(): - try: - filepath = select_file() - if not filepath: - return # 用户取消 + show_banner() - cells = read_excel(filepath) - pinmap = parse_pinmap(cells) - result = validate(pinmap) + # ── 选择转换方向 ────────────────────────────────────────── + direction = select_direction() # "map_to_list" or "list_to_map" - if result.has_errors(): - print_errors(result.errors) - return + if direction == "map_to_list": + run_map_to_list() + else: + run_list_to_map() - if result.has_warnings(): - print_warnings(result.warnings) - if not confirm_continue(): - return - pinlist = generate(pinmap, result) - output_path = build_output_path(filepath) - write_xlsx(pinlist, output_path) - print_success(output_path) +def select_direction() -> str: + """让用户选择转换方向。""" + print("请选择转换方向:") + print(" 1. PinMAP → PinList (方形布局图转引脚列表)") + print(" 2. PinList → PinMAP (引脚列表转方形布局图)") + while True: + choice = input("请输入选项 (1/2): ").strip() + if choice == "1": + return "map_to_list" + elif choice == "2": + return "list_to_map" + print("无效选项，请重新输入") - except FileFormatError as e: - print_fatal(f"文件格式错误: {e}") - except StructureError as e: - print_fatal(f"结构错误: {e}") - except ValidationError as e: - print_fatal(f"数据验证失败: {e}") - except Exception as e: - print_fatal(f"未知错误: {e}") + +def run_map_to_list(): + """PinMAP → PinList 流程（现有逻辑，增加模板格式参考）""" + # 1. 文件选择（PinMAP 文件） + # 2. 读取 Excel + # 3. 解析 PinMAP + # 4. 验证 + # 5. 生成 PinList + # 6. 写入 xlsx（如有模板则参考格式） + # 7. 结果摘要 + + +def run_list_to_map(): + """PinList → PinMAP 流程（新增）""" + # 1. 文件选择（PinList 文件） + # 2. 解析 PinList + # 3. 输入尺寸（行数、列数） + # 4. 验证 PinList 数据 + # 5. 计算布局 + # 6. 生成 PinMAP + # 7. 写入 xlsx（应用模板样式） + # 8. 结果摘要 ``` ---- +### 4.7 修改模块：`file_selector.py` -## 6. 文件处理流程图 - -``` -┌─────────────────────────────────────────────────────────────────┐ -│ 主流程 (main.py) │ -└─────────────────────────────────────────────────────────────────┘ - │ - ▼ - ┌───────────────────────────┐ - │ 1. 文件选择 (file_selector) │ - │ - tkinter 文件对话框 │ - │ - 过滤 *.xls, *.xlsx │ - └───────────┬───────────────┘ - │ - ┌───────────▼───────────────┐ - │ 2. 读取 Excel 文件 │ - │ ┌─────────────────────┐ │ - │ │ 判断文件格式 │ │ - │ │ .xls → xls_reader │ │ - │ │ .xlsx → xlsx_reader│ │ - │ └─────────┬───────────┘ │ - │ ┌─────────▼───────────┐ │ - │ │ 解析为单元格字典 │ │ - │ │ {(row,col): value} │ │ - │ └─────────┬───────────┘ │ - └────────────┬──────────────┘ - │ - ┌────────────▼──────────────┐ - │ 3. PinMAP 解析 (pinmap_parser) │ - │ ┌─────────────────────┐ │ - │ │ ① 定位方形边界 │ │ - │ │ 扫描非空单元格 │ │ - │ │ 确定 width/height│ │ - │ └─────────┬───────────┘ │ - │ ┌─────────▼───────────┐ │ - │ │ ② 提取 A1 封装信息 │ │ - │ └─────────┬───────────┘ │ - │ ┌─────────▼───────────┐ │ - │ │ ③ 沿四边提取引脚 │ │ - │ │ 上边 → 右边 │ │ - │ │ 下边 → 左边 │ │ - │ │ 逆时针排序 │ │ - │ └─────────┬───────────┘ │ - │ ┌─────────▼───────────┐ │ - │ │ ④ 组装 PinMAP 对象 │ │ - │ └─────────┬───────────┘ │ - └────────────┬──────────────┘ - │ - ┌────────────▼──────────────┐ - │ 4. 数据验证 (validator) │ - │ ┌─────────────────────┐ │ - │ │ ✓ 序号连续性检查 │ │ - │ │ ✓ 序号唯一性检查 │ │ - │ │ ✓ PinName 缺失检查 │ │ - │ │ ✓ 方形结构完整性 │ │ - │ └─────────┬───────────┘ │ - │ ┌─────────▼───────────┐ │ - │ │ ERROR → 终止流程 │ │ - │ │ WARN → 提示确认 │ │ - │ └─────────┬───────────┘ │ - └────────────┬──────────────┘ - │ - ┌────────────▼──────────────┐ - │ 5. PinList 生成 (generator) │ - │ ┌─────────────────────┐ │ - │ │ A1 = 封装信息 │ │ - │ │ A列 = PinName │ │ - │ │ B列 = Pin序号 │ │ - │ │ 按序号递增排序 │ │ - │ └─────────┬───────────┘ │ - └────────────┬──────────────┘ - │ - ┌────────────▼──────────────┐ - │ 6. XLSX 输出 (xlsx_writer) │ - │ ┌─────────────────────┐ │ - │ │ 构建 OOXML 结构 │ │ - │ │ [Content_Types].xml │ │ - │ │ xl/workbook.xml │ │ - │ │ xl/sharedStrings.xml│ │ - │ │ xl/worksheets/ │ │ - │ │ sheet1.xml │ │ - │ └─────────┬───────────┘ │ - │ ┌─────────▼───────────┐ │ - │ │ ZIP 打包输出 │ │ - │ └─────────┬───────────┘ │ - └────────────┬──────────────┘ - │ - ▼ - ┌───────────────────────────┐ - │ 完成！输出 .xlsx 文件 │ - │ 默认命名: {原文件名}_PinList.xlsx │ - └───────────────────────────┘ -``` - ---- - -## 7. PinMAP 结构详解 - -### 7.1 坐标映射 - -以 4×4 方形为例（width=4, height=4）： - -``` - col A(0) col B(1) col C(2) col D(3) -row 0 [A1=封装] [PinName] [PinName] [PinName] ← 上边PinName行 -row 1 [1] [2] [3] [4] ← 上边Pin序号行 -row 2 [PinName] [ ] [PinName] ← 中间区域（留空） -row 3 [PinName] [ ] [PinName] ← 中间区域（留空） -row 4 [13] [12] [11] [10] ← 下边Pin序号行 - [PinName] [PinName] [PinName] [PinName] ← 下边PinName行（行5） - ↑ ↑ ↑ ↑ - 左边 左边 右边 右边 - PinName PinName PinName PinName - (列前) (列前) (列后) (列后) -``` - -**实际引脚分布**： -- 上边：Pin 1(A,row1) → Pin 2(B,row1) → Pin 3(C,row1) → Pin 4(D,row1) -- 右边：Pin 5(D,row2) → Pin 6(D,row3) → Pin 7(D,row4) -- 下边：Pin 8(D,row4) ... 等等 - -等等，让我重新理清。根据需求描述： - -``` -C2 是上边最后一个Pin序号，C3是对应PinName -A4 是左边第一个Pin序号，B4是对应PinName -``` - -这说明： -- 行1（Excel第2行）= 上边Pin序号行 -- 行2（Excel第3行）= 上边PinName行 -- 行3（Excel第4行）= 左边第一个Pin序号行 - -所以方形区域从 row=1 开始（Excel第2行），row=0 是PinName行。 - -### 7.2 四边提取规则（修正版） - -设方形区域：行范围 [r_top, r_bottom]，列范围 [c_left, c_right] - -``` -上边 (Top Edge)： - Pin序号位置：row=r_top, col=c_left → c_right（从左到右） - PinName位置：row=r_top-1, col=c_left → c_right - -右边 (Right Edge)： - Pin序号位置：col=c_right, row=r_top → r_bottom（从上到下） - PinName位置：col=c_right+1, row=r_top → r_bottom - -下边 (Bottom Edge)： - Pin序号位置：row=r_bottom, col=c_right → c_left（从右到左） - PinName位置：row=r_bottom+1, col=c_right → c_left - -左边 (Left Edge)： - Pin序号位置：col=c_left, row=r_bottom → r_top（从下到上） - PinName位置：col=c_left-1, row=r_bottom → r_top（即B列，当c_left=0时） -``` - -### 7.3 角点共享规则 - -``` -左上角 (c_left, r_top) = 上边起点 = 左边终点 → Pin 1 -右上角 (c_right, r_top) = 上边终点 = 右边起点 -右下角 (c_right, r_bottom) = 右边终点 = 下边起点 -左下角 (c_left, r_bottom) = 下边终点 = 左边终点 - -总Pin数 = 2 × width + 2 × height - 4 -``` - -### 7.4 长方形支持 - -``` -非正方形示例：width=6, height=4 - -总Pin数 = 2×6 + 2×4 - 4 = 16 - -上边：6个引脚（1-6） -右边：3个引脚（7-9） -下边：5个引脚（10-14） -左边：3个引脚（15-16，回到Pin 1） - -验证：6 + 3 + 5 + 2 = 16 ✓（左边排除两个角点） -``` - ---- - -## 8. 任务拆分建议 - -### 8.1 推荐拆分方案 - -建议拆分为 **3 个子任务**，由 2-3 个编码 Agent 并行开发： - -#### 任务 A：Excel 读写引擎（最复杂，优先开发） - -**负责模块**：`xls_reader.py`, `xlsx_reader.py`, `xlsx_writer.py` - -**工作内容**： -1. 实现 BIFF8 OLE2 解析器（xls 读取） -2. 实现 ZIP+XML 解析器（xlsx 读取） -3. 实现 OOXML 生成器（xlsx 写入） -4. 统一接口：`read_excel(filepath) → dict[(row,col), str]` -5. 编写单元测试（用已知 xls/xlsx 文件验证） - -**预估工作量**：高（BIFF8 解析是最大难点） - -**关键风险**： -- BIFF8 变体多（BIFF5/BIFF8 混用、不同 Unicode 编码） -- 需要大量测试文件验证 - -#### 任务 B：PinMAP 解析与验证（核心业务逻辑） - -**负责模块**：`pinmap_parser.py`, `validator.py` - -**工作内容**： -1. 实现方形边界检测算法 -2. 实现四边引脚提取逻辑 -3. 实现角点共享处理 -4. 实现验证规则（连续性、唯一性、完整性） -5. 编写单元测试（模拟各种 PinMAP 布局） - -**预估工作量**：中 - -**关键风险**： -- 边界条件处理（长方形 vs 正方形、最小尺寸） -- 角点共享逻辑的正确性 - -#### 任务 C：流程编排与输出（集成层） - -**负责模块**：`main.py`, `file_selector.py`, `pinlist_generator.py` - -**工作内容**： -1. 实现文件选择对话框 -2. 实现 PinList 数据转换 -3. 实现输出文件命名和保存 -4. 实现主流程异常处理和用户提示 -5. 端到端集成测试 - -**预估工作量**：低 - -**关键风险**： -- tkinter 在 Windows 上的兼容性 -- 用户交互流程的友好性 - -### 8.2 开发顺序 - -``` -第1轮：任务 A（Excel 读写引擎） - ↓ 完成后 -第2轮：任务 B（PinMAP 解析与验证） - ↓ 完成后 -第3轮：任务 C（流程编排与输出） - ↓ 完成后 -集成测试 → 发布 -``` - -### 8.3 接口契约（模块间约定） +**修改内容**：支持两种文件类型的过滤。 ```python -# xls_reader / xlsx_reader 统一接口 -def read_excel_cells(filepath: str) -> dict[tuple[int, int], str]: - """ - 输入: Excel 文件路径 - 输出: {(row, col): str} 单元格字典 - 约定: row/col 从 0 开始，所有值转为 str +def select_file(direction: str) -> Optional[str]: """ + 文件选择流程。 -# pinmap_parser 接口 -def parse_pinmap(cells: dict[tuple[int, int], str]) -> PinMAP: - """ - 输入: 单元格字典 - 输出: PinMAP 对象 - 约定: 结构错误时抛出 StructureError + Parameters + ---------- + direction : str + "map_to_list" → 选择 PinMAP 文件 + "list_to_map" → 选择 PinList 文件 """ + if direction == "map_to_list": + title = "选择 PinMAP 文件" + else: + title = "选择 PinList 文件" -# validator 接口 -def validate_pinmap(pinmap: PinMAP) -> ValidationResult: - """ - 输入: PinMAP 对象 - 输出: ValidationResult - 约定: 不抛出异常，所有问题记录在 ValidationResult 中 - """ + # 复用现有逻辑，仅修改提示文本和对话框标题 +``` -# pinlist_generator 接口 -def generate_pinlist(pinmap: PinMAP, validation: ValidationResult) -> PinList: - """ - 输入: PinMAP + ValidationResult - 输出: PinList 对象 - 约定: 自动处理 WARN 级别的缺失 PinName（设为 NC） - """ +### 4.8 修改模块：`models.py` -# xlsx_writer 接口 -def write_pinlist_xlsx(pinlist: PinList, output_path: str): +**修改内容**：新增 PinList 输入相关的数据模型。 + +```python +# 新增数据模型 +@dataclass +class PinListEntry: + """PinList 中的单个引脚条目。""" + number: int + name: str + + +@dataclass +class PinMAPLayout: + """计算出的 PinMAP 布局。""" + package_info: str + rows: int + cols: int + edges: dict[str, EdgePins] # left/bottom/right/top + cells: dict[str, str] # 单元格数据 {"A2": "1", "B2": "Pin1", ...} + + +# 新增异常 +class LayoutError(PinMapError): + """布局计算错误（尺寸无效、Pin 数量不匹配等）。""" +``` + +### 4.9 修改模块：`xlsx_writer.py` + +**修改内容**：支持样式写入（用于 PinMAP 输出）。 + +```python +def write_xlsx_with_style( + data: dict[str, str], + output_path: str, + style: TemplateStyle | None = None, +): """ - 输入: PinList + 输出路径 - 输出: 无（写入文件） - 约定: 自动创建父目录 + 写入 xlsx 文件，可选应用模板样式。 + + Parameters + ---------- + data : dict[str, str] + 单元格数据 + output_path : str + 输出路径 + style : TemplateStyle | None + 模板样式（可选） """ + # 现有 write_xlsx() 保持不变（用于 PinList 输出） + # 新增 write_xlsx_with_style() 用于 PinMAP 输出（需要样式） +``` + +**样式写入实现**： +- 在 OOXML 中生成 `xl/styles.xml` +- 在 sheet1.xml 的 `` 元素中添加 `s` 属性（style index） +- 如果模板不存在，使用最小样式集（无边框、默认字体） + +### 4.10 修改模块：`validator.py` + +**修改内容**：新增 `validate_pinlist()` 函数，与现有 `validate_pinmap()` 并存。 + +```python +# 新增函数（不修改现有 validate_pinmap） +def validate_pinlist(entries, rows, cols) -> ValidationResult: + """验证 PinList 数据（独立函数，不修改现有 validate_pinmap）""" +``` + +**建议**：将 `validate_pinlist()` 放在独立的 `pinlist_validator.py` 中，保持单一职责。 + +--- + +## 5. 数据流设计 + +### 5.1 PinMAP → PinList 流程（现有 + 模板增强） + +``` +PinMAP 文件 (.xls/.xlsx) + │ + ▼ +xls_reader / xlsx_reader + │ → dict[(row,col), str] + ▼ +pinmap_parser.parse_pinmap() + │ → PinMAP + ▼ +validator.validate_pinmap() + │ → ValidationResult + ▼ +pinlist_generator.generate_pinlist() + │ → PinList + ▼ +xlsx_writer.write_xlsx() ← 如有模板，参考格式 + │ + ▼ +PinList 文件 (.xlsx) +``` + +### 5.2 PinList → PinMAP 流程（新增） + +``` +PinList 文件 (.xls/.xlsx) + │ + ▼ +pinlist_parser.parse() + │ → (package_info, entries) + ▼ +用户输入：行数、列数 + │ + ▼ +pinlist_validator.validate_pinlist() + │ → ValidationResult + │ + ├─ 缺失 PinName → 提示确认，默认 NC + ├─ 非 4 倍数 → 提示 + └─ 错误 → 终止 + ▼ +pinmap_layout.calculate_layout() + │ → dict[str, EdgePins] + ▼ +pinmap_generator.generate_pinmap() + │ → cells dict + 写入文件 + │ + └─ 检测 PinMAP-Template.xlsx + ├─ 存在 → template_reader.read_styles() → 应用样式 + └─ 不存在 → 默认样式 + ▼ +PinMAP 文件 (.xlsx) ``` --- -## 9. 项目目录结构 +## 6. PinList 文件格式规范 + +### 6.1 格式定义 + +| 单元格 | 内容 | 说明 | +|--------|------|------| +| A1 | 封装信息 | 如 "QFN-20"、"BGA-256" | +| A2 | PinName1 | 引脚名称 | +| B2 | 1 | Pin 序号 | +| A3 | PinName2 | 引脚名称 | +| B3 | 2 | Pin 序号 | +| ... | ... | ... | +| An | PinNameN | 引脚名称 | +| Bn | N | Pin 序号 | + +### 6.2 示例 ``` -pinmap-to-pinlist/ -├── Code/ -│ ├── src/ -│ │ ├── __init__.py -│ │ ├── main.py # 入口点 -│ │ ├── file_selector.py # 文件选择 -│ │ ├── xls_reader.py # XLS 读取引擎 -│ │ ├── xlsx_reader.py # XLSX 读取引擎 -│ │ ├── pinmap_parser.py # PinMAP 解析 -│ │ ├── validator.py # 数据验证 -│ │ ├── pinlist_generator.py # PinList 生成 -│ │ ├── xlsx_writer.py # XLSX 写入引擎 -│ │ └── models.py # 数据模型定义 -│ └── docs/ -│ └── architecture-design.md # 本文档 -├── Test/ -│ ├── fixtures/ # 测试用 Excel 文件 -│ │ ├── sample_4x4.xls -│ │ ├── sample_4x4.xlsx -│ │ ├── sample_rect.xls -│ │ └── ... -│ └── test_*.py # 单元测试 -└── Releases/ - └── pinmap2pinlist.exe # 打包后的可执行文件 +A1: "QFN-20" +A2: "VCC" B2: "1" +A3: "GND" B3: "2" +A4: "IN1" B4: "3" +A5: "IN2" B5: "4" +A6: "OUT1" B6: "5" +... +A21: "RST" B21: "20" +``` + +### 6.3 约束 + +- A1 不能为空（封装信息） +- B 列必须为整数（Pin 序号） +- A 列可为空（缺失时默认 NC） +- Pin 序号从 1 开始连续 +- 读取到第一个空行（A 列和 B 列都为空）为止 + +--- + +## 7. 模板格式规范 + +### 7.1 模板文件 + +- **文件名**：`PinMAP-Template.xlsx` +- **位置**：程序根目录（与 `run.bat` 同级） +- **作用**：提供输出 PinMAP 文件的样式参考 + +### 7.2 模板内容 + +模板文件应包含： +- 正确的方形布局结构（用于参考单元格位置） +- 单元格样式：字体、字号、边框、填充色、对齐方式 +- 列宽和行高设置 + +### 7.3 模板使用方式 + +- 模板**仅用于样式参考**，不用于结构参考 +- 程序从模板提取：字体、边框、填充、对齐、列宽、行高 +- 实际引脚数据由 PinList 决定 +- 模板不存在时，使用默认样式（无边框、Calibri 11号、居中对齐） + +--- + +## 8. 交互流程设计 + +### 8.1 启动 Banner + +``` +============================================================ + PinMAP ↔ PinList 双向转换器 + 自动在方形布局图与引脚列表之间转换 + 支持.xls和.xlsx格式，输出.xlsx格式 +============================================================ + +请选择转换方向: + 1. PinMAP → PinList (方形布局图转引脚列表) + 2. PinList → PinMAP (引脚列表转方形布局图) +请输入选项 (1/2): +``` + +### 8.2 PinList → PinMAP 完整交互流程 + +``` +[INFO] 正在读取 PinList 文件: C:\test\pinlist.xlsx +[INFO] 文件读取完成，共 20 个引脚 +[INFO] 封装信息: QFN-20 + +请输入 PinMAP 尺寸: + 行数: 4 + 列数: 8 + +[INFO] 正在验证数据... +[WARN] 检测到 2 个引脚缺少 PinName，将默认为 NC +[INFO] Pin数量 (20) 是 4 的倍数，四条边均匀分布 +[INFO] 验证通过 + +[INFO] 正在计算 PinMAP 布局... +[INFO] 布局计算完成: 4×8 网格，左边4个 + 下边8个 + 右边3个 + 上边5个 +[INFO] 检测到模板文件: PinMAP-Template.xlsx +[INFO] 正在生成 PinMAP... +[INFO] 正在写入输出文件: C:\test\pinlist_PinMAP.xlsx + +[SUCCESS] 转换完成！ + 输出文件: C:\test\pinlist_PinMAP.xlsx + 封装信息: QFN-20 + 网格尺寸: 4×8 + Pin数量: 20 + 模板: 已应用 +``` + +### 8.3 错误处理交互 + +``` +[ERROR] Pin序号不连续，缺失: [3, 7, 15] +转换终止，请修正 PinList 文件后重试。 + +按 Enter 键退出... +``` + +``` +[ERROR] Pin数量 (18) 与网格周长 (20) 不匹配 + 网格 4×8 需要 20 个引脚，但 PinList 只有 18 个 +转换终止，请检查尺寸或 PinList 数据。 + +按 Enter 键退出... ``` --- -## 10. 风险与缓解 +## 9. 工作量评估 + +### 9.1 开发任务拆分 + +| 任务编号 | 任务 | 文件 | 工作量 | 依赖 | +|---------|------|------|--------|------| +| **T1** | PinList 解析器 | `pinlist_parser.py` | 1h | 无 | +| **T2** | PinList 验证器 | `pinlist_validator.py` | 1h | T1 | +| **T3** | PinMAP 布局计算 | `pinmap_layout.py` | 2h | T1, T2 | +| **T4** | PinMAP 生成器 | `pinmap_generator.py` | 1.5h | T3 | +| **T5** | 模板读取器 | `template_reader.py` | 2.5h | 无 | +| **T6** | xlsx_writer 样式支持 | `xlsx_writer.py` | 2h | T5 | +| **T7** | main.py 双向改造 | `main.py` | 1.5h | T1-T6 | +| **T8** | file_selector 修改 | `file_selector.py` | 0.5h | T7 | +| **T9** | models.py 扩展 | `models.py` | 0.5h | T1 | +| **T10** | 测试用例 | `test_pinlist.py` | 2h | T1-T9 | +| **T11** | 测试数据文件 | `Test/fixtures/` | 1h | T10 | + +**总计预估**：约 15.5 小时（约 2 个工作日） + +### 9.2 复杂度分级 + +| 复杂度 | 任务 | 原因 | +|--------|------|------| +| **低** | T1, T2, T8, T9 | 逻辑简单，复用现有代码 | +| **中** | T3, T4, T7 | 核心业务逻辑，需仔细处理边界条件 | +| **高** | T5, T6, T10 | OOXML 样式解析/写入复杂，测试覆盖全面 | + +### 9.3 推荐开发顺序 + +``` +第1轮（并行）： + T1: PinList 解析器 + T5: 模板读取器（可独立开发） + +第2轮（依赖 T1）： + T2: PinList 验证器 + T3: PinMAP 布局计算 + +第3轮（依赖 T2, T3）： + T4: PinMAP 生成器 + T6: xlsx_writer 样式支持 + +第4轮（集成）： + T7: main.py 双向改造 + T8: file_selector 修改 + T9: models.py 扩展 + +第5轮（测试）： + T10: 测试用例 + T11: 测试数据文件 +``` + +--- + +## 10. 风险评估 | 风险 | 影响 | 概率 | 缓解措施 | |------|------|------|---------| -| BIFF8 格式变体导致解析失败 | 高 | 中 | 收集多种 xls 样本测试；优先实现 BIFF8 最常见子集 | -| tkinter 在无头环境不可用 | 中 | 低 | 回退到命令行参数模式 | -| xlsx 写入的 XML 结构不兼容老版本 Excel | 中 | 低 | 遵循 OOXML 标准，使用最小兼容集 | -| 超大文件（>1000引脚）性能问题 | 低 | 低 | 当前场景引脚数通常 <100，无需优化 | +| OOXML styles.xml 解析复杂度高 | 高 | 中 | 先实现最小可用样式集（字体+边框），逐步完善 | +| Pin 数量与周长不匹配的用户输入 | 中 | 高 | 在 validator 中严格检查，给出明确的错误提示 | +| 模板文件存在但格式异常 | 中 | 低 | 优雅降级：模板解析失败时回退到默认样式 | +| 非 4 倍数 Pin 数量的边界处理 | 低 | 中 | 明确文档化分配公式，测试各种尺寸组合 | +| 双向交互流程的用户体验 | 中 | 低 | 保持与现有流程一致的交互风格 | --- -## 11. 附录 +## 11. 与现有架构的兼容性 -### A. BIFF8 记录类型速查 +### 11.1 向后兼容 -| 记录码 | 名称 | 说明 | -|--------|------|------| -| 0x0009 | BOF | 块起始 | -| 0x000A | EOF | 文件结束 | -| 0x00FD | LABELSST | 共享字符串表引用单元格 | -| 0x0203 | NUMBER | 浮点数单元格 | -| 0x0006 | FORMULA | 公式单元格 | -| 0x000C | RK | RK 数值 | -| 0x00FC | STRING | 公式字符串结果 | -| 0x0034 | SST | 全局共享字符串表 | -| 0x0042 | BOUNDSHEET | 工作表信息 | -| 0x00E0 | EXTSST | 扩展共享字符串表 | +- 现有 PinMAP → PinList 流程**完全不受影响** +- 新增模块与现有模块**松耦合**，通过接口交互 +- 模板功能为**可选增强**，不影响无模板场景 -### B. OOXML xlsx 目录结构 +### 11.2 代码复用 -``` -example.xlsx (ZIP) -├── [Content_Types].xml -├── _rels/ -│ └── .rels -├── xl/ -│ ├── workbook.xml -│ ├── _rels/ -│ │ └── workbook.xml.rels -│ ├── sharedStrings.xml -│ ├── styles.xml -│ └── worksheets/ -│ ├── sheet1.xml -│ └── sheet2.xml -└── docProps/ - ├── core.xml - └── app.xml -``` +| 现有模块 | 复用方式 | +|---------|---------| +| `xls_reader.py` | PinList 解析直接复用 | +| `xlsx_reader.py` | PinList 解析 + 模板读取复用 ZIP/XML 解析 | +| `models.py` | 扩展新增数据模型 | +| `utils.py` | 坐标转换工具直接复用 | +| `xlsx_writer.py` | 扩展新增样式写入能力 | -### C. 列字母 ↔ 索引转换 +### 11.3 零第三方依赖保持 + +所有新增功能仍使用 Python 标准库实现： +- Excel 读写：`zipfile` + `xml.etree.ElementTree` + `struct` +- 文件选择：`tkinter.filedialog` +- 样式解析：`xml.etree.ElementTree` + +--- + +## 12. 测试策略 + +### 12.1 单元测试 ```python -def col_letter_to_index(letter: str) -> int: - """A→0, B→1, ..., Z→25, AA→26, AB→27, ...""" - result = 0 - for ch in letter.upper(): - result = result * 26 + (ord(ch) - ord('A') + 1) - return result - 1 +# test_pinlist.py -def col_index_to_letter(index: int) -> str: - """0→A, 1→B, ..., 25→Z, 26→AA, ...""" - result = "" - index += 1 - while index > 0: - index -= 1 - result = chr(index % 26 + ord('A')) + result - index //= 26 - return result +def test_pinlist_parse_basic(): + """基本 PinList 解析""" + +def test_pinlist_parse_unsorted(): + """PinList 序号非顺序排列""" + +def test_pinlist_parse_missing_names(): + """缺失 PinName 的处理""" + +def test_pinlist_validate_continuous(): + """连续性验证""" + +def test_pinlist_validate_duplicate(): + """重复序号验证""" + +def test_pinlist_validate_perimeter_match(): + """周长匹配验证""" + +def test_layout_4x4(): + """4×4 网格布局计算""" + +def test_layout_4x8(): + """4×8 长方形布局计算""" + +def test_layout_non_multiple_of_4(): + """非 4 倍数 Pin 数量布局""" + +def test_template_read(): + """模板样式读取""" + +def test_pinmap_generate(): + """PinMAP 生成与写入""" ``` +### 12.2 集成测试 + +| 测试场景 | 输入 | 预期 | +|---------|------|------| +| 正向转换 | sample_4x4.xlsx | 生成 PinList，与手动结果一致 | +| 反向转换 | 生成的 PinList | 还原为原始 PinMAP | +| 往返转换 | PinMAP → PinList → PinMAP | 与原始 PinMAP 一致 | +| 模板应用 | PinList + Template | 输出文件样式与模板一致 | +| 无模板 | PinList（无模板） | 输出文件使用默认样式 | +| 错误输入 | 缺失序号的 PinList | 报错并终止 | +| 尺寸不匹配 | PinList + 错误尺寸 | 报错并终止 | + +--- + +## 13. 接口契约 + +### 13.1 新增模块接口 + +```python +# pinlist_parser.py +def parse_pinlist(filepath: str) -> tuple[str, list[PinListEntry]]: + """ + 输入: PinList 文件路径 + 输出: (封装信息, 按序号排序的引脚列表) + """ + +# pinlist_validator.py +def validate_pinlist( + entries: list[PinListEntry], + rows: int, + cols: int, +) -> ValidationResult: + """ + 输入: 引脚列表 + 尺寸 + 输出: ValidationResult + """ + +# pinmap_layout.py +def calculate_layout( + entries: list[PinListEntry], + rows: int, + cols: int, +) -> dict[str, EdgePins]: + """ + 输入: 引脚列表 + 尺寸 + 输出: 四条边的引脚分配 + """ + +# pinmap_generator.py +def generate_pinmap( + entries: list[PinListEntry], + rows: int, + cols: int, + package_info: str, + template_style: TemplateStyle | None = None, + output_path: str | None = None, +) -> dict[str, str]: + """ + 输入: 引脚数据 + 尺寸 + 封装 + 可选模板样式 + 输出: 单元格数据字典 + """ + +# template_reader.py +def read_template_styles(filepath: str) -> TemplateStyle | None: + """ + 输入: 模板文件路径 + 输出: 模板样式（不存在或解析失败时返回 None） + """ +``` + +--- + +## 14. 总结 + +| 项目 | 内容 | +|------|------| +| 新增模块数 | 5 个 | +| 修改模块数 | 5 个 | +| 不变模块数 | 5 个 | +| 技术难度 | 中（核心难点在 OOXML 样式处理） | +| 预估工作量 | ~15.5 小时（约 2 个工作日） | +| 推荐 Agent | Python 编码 Agent（1-2 个） | +| 风险等级 | 中低 | +| 第三方依赖 | 零新增 | + +**结论**： +1. PinList → PinMAP 反向转换在技术上完全可行 +2. 核心难点在于 OOXML 样式解析/写入，但可通过最小可用集逐步实现 +3. 布局分配算法清晰，公式化计算，边界条件可控 +4. 建议分 5 轮迭代开发，先完成核心转换逻辑，再增强模板支持 +5. 与现有架构完全兼容，向后无破坏性变更 + --- *文档结束 — 请审批后进入编码阶段* diff --git a/Code/src/file_selector.py b/Code/src/file_selector.py index 2838339..fd7ecce 100644 --- a/Code/src/file_selector.py +++ b/Code/src/file_selector.py @@ -1,17 +1,35 @@ """File selector — CLI path input with GUI dialog fallback. -Provides a single function ``select_file`` that: +Provides ``select_file`` that: 1. Prompts the user to type a file path. 2. If the input is empty, opens a tkinter file-dialog. 3. If the path does not exist, reports an error and loops back. 4. Repeats until a valid path is entered or the user cancels. + +Supports two modes via the ``mode`` parameter: + - "map_to_list" : select a PinMAP file (default) + - "list_to_map" : select a PinList file """ import os from typing import Optional -def _gui_select() -> Optional[str]: +# ── Mode-specific labels ──────────────────────────────────────────── + +_MODE_LABELS = { + "map_to_list": { + "dialog_title": "选择 PinMAP 文件", + "prompt": "请输入PinMAP文件路径（直接回车弹窗选择）: ", + }, + "list_to_map": { + "dialog_title": "选择 PinList 文件", + "prompt": "请输入PinList文件路径（直接回车弹窗选择）: ", + }, +} + + +def _gui_select(title: str) -> Optional[str]: """弹出 tkinter 文件选择对话框，返回选中路径或 None。""" try: import tkinter @@ -22,7 +40,7 @@ def _gui_select() -> Optional[str]: root.attributes("-topmost", True) filepath = tkinter.filedialog.askopenfilename( - title="选择 PinMAP 文件", + title=title, filetypes=[ ("Excel 文件", "*.xls *.xlsx"), ("所有文件", "*.*"), @@ -39,20 +57,31 @@ def _gui_select() -> Optional[str]: return None -def select_file() -> Optional[str]: +def select_file(mode: str = "map_to_list") -> Optional[str]: """ - 文件选择流程： - 1. 提示用户输入文件路径 - 2. 如果输入为空，弹窗选择文件 - 3. 如果输入的路径不存在，报错并提示重新输入 - 4. 循环直到用户输入有效路径或取消 + 文件选择流程。 + + Parameters + ---------- + mode : str + "map_to_list" — 选择 PinMAP 文件（默认） + "list_to_map" — 选择 PinList 文件 + + Returns + ------- + str | None + 选中的文件路径；用户取消时返回 None """ + labels = _MODE_LABELS.get(mode, _MODE_LABELS["map_to_list"]) + prompt = labels["prompt"] + dialog_title = labels["dialog_title"] + while True: - filepath = input("请输入PinMAP文件路径（直接回车弹窗选择）: ").strip().strip('"\'') + filepath = input(prompt).strip().strip('"\'') if not filepath: # 弹窗选择 - filepath = _gui_select() + filepath = _gui_select(dialog_title) if not filepath: return None return filepath diff --git a/Code/src/main.py b/Code/src/main.py index 2df0ad6..76947ec 100644 --- a/Code/src/main.py +++ b/Code/src/main.py @@ -1,19 +1,21 @@ -"""PinMAP → PinList converter +"""PinMAP ↔ PinList bidirectional converter Usage: - python main.py # Interactive file selection - python main.py input.xls # Specify file via command line + python main.py # Interactive — choose direction + file + python main.py input.xls # MAP→List mode (legacy, specify file directly) """ import sys import os +# ── Banner ────────────────────────────────────────────────────────── + def show_banner(): """显示程序启动说明""" print("=" * 60) - print(" PinMAP → PinList 转换器") - print(" 将Excel格式的PinMAP文件转换为PinList格式") + print(" PinMAP ↔ PinList 双向转换器") + print(" 支持 PinMAP→PinList 与 PinList→PinMAP 互转") print(" 支持.xls和.xlsx格式，输出.xlsx格式") print("=" * 60) print() @@ -29,19 +31,26 @@ def wait_for_exit(): input("按Enter键退出...") -def build_output_path(input_path: str) -> str: +# ── Path helpers ──────────────────────────────────────────────────── + +def _build_output_path_map_to_list(input_path: str) -> str: """Generate output path: {original_filename}_PinList.xlsx""" base, _ = os.path.splitext(input_path) return f"{base}_PinList.xlsx" -def main(): - # ── Banner ────────────────────────────────────────────────── - show_banner() +def _build_output_path_list_to_map(input_path: str) -> str: + """Generate output path: {original_filename}_PinMAP.xlsx""" + base, _ = os.path.splitext(input_path) + return f"{base}_PinMAP.xlsx" - # ── imports (local to avoid circular issues) ──────────────── + +# ── Direction 1: MAP → List ──────────────────────────────────────── + +def run_map_to_list(filepath: str): + """执行 PinMAP → PinList 转换流程。""" from file_selector import select_file - from xls_reader import read_excel_cells # auto-detects .xls + from xls_reader import read_excel_cells from xlsx_reader import read_excel_cells as read_xlsx_cells from pinmap_parser import parse_pinmap from validator import validate_pinmap @@ -49,18 +58,16 @@ def main(): from xlsx_writer import write_xlsx from models import FileFormatError, StructureError - # ── 1. File selection ─────────────────────────────────────── - if len(sys.argv) > 1: - filepath = sys.argv[1] - else: - filepath = select_file() + # ── 1. File selection ─────────────────────────────────────────── + if not filepath: + filepath = select_file(mode="map_to_list") if not filepath: print("未选择文件，退出。") wait_for_exit() return - # ── 2. Read Excel ─────────────────────────────────────────── + # ── 2. Read Excel ─────────────────────────────────────────────── print(f"[INFO] 正在读取文件: {filepath}") try: if filepath.lower().endswith('.xlsx'): @@ -74,7 +81,7 @@ def main(): print(f"[INFO] 文件读取完成，共 {len(cells)} 个非空单元格") - # ── 3. Parse PinMAP ───────────────────────────────────────── + # ── 3. Parse PinMAP ───────────────────────────────────────────── print("[INFO] 正在解析 PinMAP 结构...") try: pinmap = parse_pinmap(cells) @@ -85,7 +92,7 @@ def main(): wait_for_exit() return - # ── 4. Validate ───────────────────────────────────────────── + # ── 4. Validate ───────────────────────────────────────────────── print("[INFO] 正在验证数据...") validation = validate_pinmap(pinmap) @@ -97,7 +104,6 @@ def main(): wait_for_exit() return - # Print warnings (non-fatal — continue processing) if validation.warnings: print(f"[WARN] 发现 {len(validation.warnings)} 个警告:") for warn in validation.warnings: @@ -105,18 +111,18 @@ def main(): else: print("[INFO] 验证通过") - # ── 5. Generate PinList ───────────────────────────────────── + # ── 5. Generate PinList ───────────────────────────────────────── print("[INFO] 正在生成 PinList...") pinlist = generate_pinlist(pinmap, validation) - # ── 6. Write XLSX ─────────────────────────────────────────── - output_path = build_output_path(filepath) + # ── 6. Write XLSX ─────────────────────────────────────────────── + output_path = _build_output_path_map_to_list(filepath) print(f"[INFO] 正在写入输出文件: {output_path}") try: data = {} data['A1'] = pinlist.package_info for i, (pin_name, pin_num) in enumerate(pinlist.rows): - row = i + 2 # data rows start at row 2 + row = i + 2 data[f'A{row}'] = pin_name data[f'B{row}'] = str(pin_num) @@ -126,7 +132,7 @@ def main(): wait_for_exit() return - # ── 7. Result summary ─────────────────────────────────────── + # ── 7. Result summary ─────────────────────────────────────────── print() print("[SUCCESS] 转换完成！") print(f" 输出文件: {output_path}") @@ -136,5 +142,157 @@ def main(): wait_for_exit() +# ── Direction 2: List → MAP ──────────────────────────────────────── + +def run_list_to_map(filepath: str): + """执行 PinList → PinMAP 转换流程。""" + from file_selector import select_file + from pinlist_parser import parse_pinlist + from pinlist_validator import validate_pinlist + from pinmap_generator import generate_pinmap, generate_output_path + from template_reader import read_template_styles + from models import StructureError, LayoutError + + # ── 1. File selection ─────────────────────────────────────────── + if not filepath: + filepath = select_file(mode="list_to_map") + + if not filepath: + print("未选择文件，退出。") + wait_for_exit() + return + + # ── 2. Input PinMAP dimensions ────────────────────────────────── + while True: + try: + rows_input = input("请输入 PinMAP 行数: ").strip() + rows = int(rows_input) + if rows < 2: + print("[ERROR] 行数至少为 2") + continue + break + except ValueError: + print("[ERROR] 请输入有效的整数") + + while True: + try: + cols_input = input("请输入 PinMAP 列数: ").strip() + cols = int(cols_input) + if cols < 2: + print("[ERROR] 列数至少为 2") + continue + break + except ValueError: + print("[ERROR] 请输入有效的整数") + + print(f"[INFO] PinMAP 尺寸: {rows} 行 × {cols} 列") + + # ── 3. Parse PinList ──────────────────────────────────────────── + print(f"[INFO] 正在解析 PinList 文件: {filepath}") + try: + package_info, entries = parse_pinlist(filepath) + print(f"[INFO] 解析完成: 封装信息 '{package_info}', 共 {len(entries)} 个引脚") + except StructureError as e: + print(f"[FATAL] 解析失败: {e}") + wait_for_exit() + return + + # ── 4. Validate ───────────────────────────────────────────────── + print("[INFO] 正在验证数据...") + validation = validate_pinlist(entries, rows, cols) + + if validation.errors: + print(f"[ERROR] 验证未通过，发现 {len(validation.errors)} 个错误:") + for err in validation.errors: + print(f" - {err.message}: {err.details}") + print("\n转换终止，请修正PinList文件或网格尺寸后重试。") + wait_for_exit() + return + + if validation.warnings: + print(f"[WARN] 发现 {len(validation.warnings)} 个警告:") + for warn in validation.warnings: + print(f" - {warn.message}: {warn.details}") + else: + print("[INFO] 验证通过") + + # ── 5. Generate PinMAP ────────────────────────────────────────── + output_path = generate_output_path(filepath) + print(f"[INFO] 正在生成 PinMAP 并写入: {output_path}") + + try: + # 尝试读取模板样式（优雅降级） + template_style = read_template_styles(filepath) + + generate_pinmap( + entries=entries, + rows=rows, + cols=cols, + package_info=package_info, + template_style=template_style, + output_path=output_path, + ) + except LayoutError as e: + print(f"[FATAL] 布局计算失败: {e}") + wait_for_exit() + return + except Exception as e: + print(f"[FATAL] 输出失败: {e}") + wait_for_exit() + return + + # ── 6. Result summary ─────────────────────────────────────────── + print() + print("[SUCCESS] 转换完成！") + print(f" 输出文件: {output_path}") + print(f" 封装信息: {package_info}") + print(f" PinMAP 尺寸: {rows}×{cols}") + print(f" Pin数量: {len(entries)}") + + wait_for_exit() + + +# ── Main entry ────────────────────────────────────────────────────── + +def main(): + show_banner() + + # ── Direction selection ───────────────────────────────────────── + if len(sys.argv) > 1: + # Legacy mode: direct file argument → MAP→List + direction = 1 + filepath = sys.argv[1] + else: + print("请选择转换方向:") + print(" 1 — PinMAP → PinList") + print(" 2 — PinList → PinMAP") + print() + + while True: + choice = input("请输入选项 (1/2): ").strip() + if choice in ('1', '2'): + direction = int(choice) + break + print("[ERROR] 无效选项，请输入 1 或 2") + + filepath = None # will be selected inside the flow + + # ── Dispatch ──────────────────────────────────────────────────── + if direction == 1: + print() + print("─" * 40) + print(" 方向: PinMAP → PinList") + print("─" * 40) + print() + run_map_to_list(filepath) + else: + print() + print("─" * 40) + print(" 方向: PinList → PinMAP") + print("─" * 40) + print() + run_list_to_map(filepath) + + if __name__ == '__main__': main() diff --git a/Code/src/models.py b/Code/src/models.py index 7664034..944c9d8 100644 --- a/Code/src/models.py +++ b/Code/src/models.py @@ -46,6 +46,31 @@ class ValidationResult: warnings: list[ValidationError] = field(default_factory=list) +@dataclass +class PinListEntry: + """A single pin entry from the PinList.""" + number: int # Pin 序号（B 列） + name: str # PinName（A 列，可能为空） + + +@dataclass +class EdgePins: + """Pins assigned to one edge of the PinMAP.""" + edge: str # "left" | "bottom" | "right" | "top" + pins: list[tuple[int, str]] # [(number, name), ...] + cells: list[tuple[int, int]] # 对应的单元格坐标 (row, col) 0-based + + +@dataclass +class PinMAPLayout: + """计算出的 PinMAP 布局。""" + package_info: str + rows: int + cols: int + edges: dict[str, EdgePins] # left/bottom/right/top + cells: dict[str, str] # 单元格数据 {"A2": "1", "B2": "Pin1", ...} + + # ── Custom exceptions ────────────────────────────────────────────── class PinMapError(Exception): @@ -58,3 +83,7 @@ class FileFormatError(PinMapError): class StructureError(PinMapError): """Raised when the PinMAP structure is invalid or unrecognisable.""" + + +class LayoutError(PinMapError): + """布局计算错误（尺寸无效、Pin 数量不匹配等）。""" diff --git a/Code/src/pinlist_parser.py b/Code/src/pinlist_parser.py new file mode 100644 index 0000000..568eb45 --- /dev/null +++ b/Code/src/pinlist_parser.py @@ -0,0 +1,116 @@ +"""PinList parser — reads a flat pin list from an Excel file. + +Reads an .xls or .xlsx file in PinList format: + - A1: package info (e.g. "QFN-20") + - Column A (from A2): PinName + - Column B (from B2): Pin number (integer) + +Reuses xls_reader / xlsx_reader for file I/O. +""" + +import os + +from models import StructureError, PinListEntry +from xlsx_reader import read_excel_cells as read_xlsx_cells +from xls_reader import read_excel_cells as read_xls_cells + + +def _detect_format(filepath: str) -> str: + """Return 'xlsx' or 'xls' based on file extension.""" + ext = os.path.splitext(filepath)[1].lower() + if ext == '.xlsx': + return 'xlsx' + elif ext == '.xls': + return 'xls' + else: + raise StructureError(f"不支持的文件格式: {ext}，仅支持 .xls 和 .xlsx") + + +def _read_cells(filepath: str) -> dict[tuple[int, int], str]: + """Read all cells from an Excel file (xls or xlsx).""" + fmt = _detect_format(filepath) + if fmt == 'xlsx': + return read_xlsx_cells(filepath) + else: + return read_xls_cells(filepath) + + +class PinListParser: + """Parse a PinList Excel file.""" + + def __init__(self, filepath: str): + self._filepath = filepath + + def parse(self) -> tuple[str, list[PinListEntry]]: + """ + 解析 PinList 文件。 + + Returns + ------- + (package_info, entries) + package_info: A1 单元格的封装信息 + entries: 按 Pin 序号排序的引脚列表 + + Raises + ------ + StructureError + A1 为空、A/B 列无数据、序号非整数等 + """ + cells = _read_cells(self._filepath) + + # 1. 提取 A1 封装信息 + package_info = cells.get((0, 0), '').strip() + if not package_info: + raise StructureError("A1 单元格为空，无法获取封装信息") + + # 2. 解析 A 列 (PinName) 和 B 列 (Pin序号) + entries: list[PinListEntry] = [] + row = 1 # 从第 2 行开始（A2, B2） + + while True: + pin_name = cells.get((row, 0), '').strip() # A 列 + pin_num_str = cells.get((row, 1), '').strip() # B 列 + + # 遇到第一个空行（A列和B列都为空）时停止 + if not pin_name and not pin_num_str: + break + + # B 列必须为有效整数 + if not pin_num_str: + raise StructureError(f"第 {row + 1} 行 B 列为空，缺少 Pin 序号") + + try: + pin_num = int(float(pin_num_str)) # 支持 "1.0" 等格式 + except ValueError: + raise StructureError( + f"第 {row + 1} 行 B 列 '{pin_num_str}' 不是有效的整数" + ) + + entries.append(PinListEntry(number=pin_num, name=pin_name)) + row += 1 + + if not entries: + raise StructureError("未找到任何引脚数据（A/B 列为空）") + + # 3. 按 Pin 序号排序 + entries.sort(key=lambda e: e.number) + + return package_info, entries + + +def parse_pinlist(filepath: str) -> tuple[str, list[PinListEntry]]: + """ + 便捷函数：解析 PinList 文件。 + + Parameters + ---------- + filepath : str + PinList 文件路径 + + Returns + ------- + (package_info, entries) + 封装信息和按序号排序的引脚列表 + """ + parser = PinListParser(filepath) + return parser.parse() diff --git a/Code/src/pinlist_validator.py b/Code/src/pinlist_validator.py new file mode 100644 index 0000000..a3f140c --- /dev/null +++ b/Code/src/pinlist_validator.py @@ -0,0 +1,112 @@ +"""PinList validator — checks pin data integrity. + +Validates a PinList for: + 1. Pin numbers starting from 1 with no gaps + 2. No duplicate pin numbers + 3. Total pin count matches grid perimeter (2×rows + 2×cols − 4) + 4. Missing PinName defaults to NC (warning) + 5. Pin count not a multiple of 4 (info) +""" + +from models import PinListEntry, ValidationResult, ValidationError + + +def validate_pinlist( + entries: list[PinListEntry], + rows: int, + cols: int, +) -> ValidationResult: + """ + 验证 PinList 数据。 + + 检查项： + 1. Pin 序号从 1 开始连续无缺失 + 2. Pin 序号无重复 + 3. Pin 总数 = 2×rows + 2×cols − 4（周长匹配） + 4. Pin 缺少 PinName 时默认为 NC（warning） + 5. Pin 数量不是 4 的倍数时提示（info） + + Parameters + ---------- + entries : list[PinListEntry] + 已按序号排序的引脚列表 + rows : int + 用户输入的 PinMAP 行数 + cols : int + 用户输入的 PinMAP 列数 + + Returns + ------- + ValidationResult + """ + errors: list[ValidationError] = [] + warnings: list[ValidationError] = [] + infos: list[ValidationError] = [] + + numbers = [e.number for e in entries] + + # ── 1. 连续性检查 ──────────────────────────────────────────── + expected_numbers = list(range(1, len(numbers) + 1)) + if numbers != expected_numbers: + missing = set(expected_numbers) - set(numbers) + if missing: + errors.append(ValidationError( + level="error", + message="Pin序号不连续", + details=f"缺失的序号: {sorted(missing)}", + )) + + # ── 2. 唯一性检查 ──────────────────────────────────────────── + if len(numbers) != len(set(numbers)): + from collections import Counter + counts = Counter(numbers) + duplicates = sorted(n for n, c in counts.items() if c > 1) + errors.append(ValidationError( + level="error", + message="Pin序号存在重复", + details=f"重复的序号: {duplicates}", + )) + + # ── 3. 周长匹配 ────────────────────────────────────────────── + expected_total = 2 * rows + 2 * cols - 4 + actual_total = len(entries) + if actual_total != expected_total: + errors.append(ValidationError( + level="error", + message="Pin数量与网格周长不匹配", + details=( + f"网格 {rows}×{cols} 需要 {expected_total} 个引脚，" + f"但 PinList 有 {actual_total} 个" + ), + )) + + # ── 4. 缺失 PinName（warning）──────────────────────────────── + missing_names = [e for e in entries if not e.name or not e.name.strip()] + if missing_names: + warnings.append(ValidationError( + level="warning", + message=f"检测到 {len(missing_names)} 个引脚缺少 PinName", + details=( + f"缺失引脚序号: {[e.number for e in missing_names]}，" + f"将默认为 NC" + ), + )) + + # ── 5. 非 4 倍数提示（info）────────────────────────────────── + if actual_total % 4 != 0: + infos.append(ValidationError( + level="info", + message="Pin数量不是4的倍数", + details=( + f"Pin数量 ({actual_total}) 不是 4 的倍数，" + f"四条边将不均匀分布" + ), + )) + + is_valid = len(errors) == 0 + + return ValidationResult( + is_valid=is_valid, + errors=errors, + warnings=warnings, + ) diff --git a/Code/src/pinmap_generator.py b/Code/src/pinmap_generator.py new file mode 100644 index 0000000..587b2cf --- /dev/null +++ b/Code/src/pinmap_generator.py @@ -0,0 +1,86 @@ +"""PinMAP generator — builds PinMAP cell data and writes to xlsx. + +Takes layout calculation results and produces: + 1. A cell data dictionary (cell_ref → value) + 2. An xlsx output file with optional template styling +""" + +import os +from typing import Optional + +from models import PinListEntry, LayoutError +from pinmap_layout import calculate_layout, get_name_cell +from template_reader import TemplateStyle +from utils import rc_to_cell_ref +from xlsx_writer import write_xlsx, write_xlsx_with_style + + +def generate_pinmap( + entries: list[PinListEntry], + rows: int, + cols: int, + package_info: str, + template_style: Optional[TemplateStyle] = None, + output_path: Optional[str] = None, +) -> dict[str, str]: + """ + 生成 PinMAP 布局并写入文件。 + + Parameters + ---------- + entries : list[PinListEntry] + PinList 数据 + rows : int + PinMAP 行数 + cols : int + PinMAP 列数 + package_info : str + 封装信息（写入 A1） + template_style : TemplateStyle | None + 模板样式（可选） + output_path : str | None + 输出文件路径 + + Returns + ------- + dict[str, str] + 单元格数据字典 {"A1": "封装", "A2": "1", "B2": "Pin1", ...} + """ + # 1. 计算布局 + layout = calculate_layout(entries, rows, cols) + + # 2. 构建单元格数据 + data: dict[str, str] = {} + data["A1"] = package_info + + # 先写入 PinName 单元格 + for edge_name, edge in layout.items(): + for (pin_num, pin_name), num_cell in zip(edge.pins, edge.cells): + name_cell = get_name_cell(num_cell, edge_name) + name_ref = rc_to_cell_ref(name_cell[0], name_cell[1]) + data[name_ref] = pin_name if pin_name and pin_name.strip() else "NC" + + # 再写入序号单元格（覆盖同位置的名字，确保序号优先） + for edge_name, edge in layout.items(): + for (pin_num, pin_name), num_cell in zip(edge.pins, edge.cells): + num_ref = rc_to_cell_ref(num_cell[0], num_cell[1]) + data[num_ref] = str(pin_num) + + # 3. 写入文件（应用模板样式） + if output_path: + if template_style is not None: + write_xlsx_with_style(data, output_path, template_style) + else: + write_xlsx(data, output_path) + + return data + + +def generate_output_path(input_path: str) -> str: + r""" + 根据输入文件路径生成默认输出路径。 + + 例如: C:\test\pinlist.xlsx → C:\test\pinlist_PinMAP.xlsx + """ + base, _ = os.path.splitext(input_path) + return base + "_PinMAP.xlsx" diff --git a/Code/src/pinmap_layout.py b/Code/src/pinmap_layout.py new file mode 100644 index 0000000..aefde16 --- /dev/null +++ b/Code/src/pinmap_layout.py @@ -0,0 +1,143 @@ +"""PinMAP layout calculator — distributes pins to four edges. + +Computes the cell coordinates for each pin on the four edges of a +rectangular PinMAP grid, using counter-clockwise ordering starting +from the top-left corner (pin 1). + +Edge assignment (counter-clockwise, top-left = pin 1): + left → rows pins + bottom → cols-1 pins + right → rows-2 pins + top → cols-1 pins + +Total: rows + (cols-1) + (rows-2) + (cols-1) = 2×rows + 2×cols − 4 +""" + +from models import PinListEntry, EdgePins, LayoutError + + +def calculate_layout( + entries: list[PinListEntry], + rows: int, + cols: int, +) -> dict[str, EdgePins]: + """ + 计算 PinMAP 布局。 + + 逆时针分配（左上角为 1 脚）： + 左边 → 下边 → 右边 → 上边 + + Parameters + ---------- + entries : list[PinListEntry] + 已按序号排序的引脚列表 + rows : int + PinMAP 行数 + cols : int + PinMAP 列数 + + Returns + ------- + dict[str, EdgePins] + {"left": ..., "bottom": ..., "right": ..., "top": ...} + + Raises + ------ + LayoutError + 尺寸无效（rows < 2 或 cols < 2） + """ + # ── 参数校验 ────────────────────────────────────────────────── + if rows < 2: + raise LayoutError(f"行数无效: {rows}，至少需要 2 行") + if cols < 2: + raise LayoutError(f"列数无效: {cols}，至少需要 2 列") + + # ── 边分配计数 ──────────────────────────────────────────────── + left_count = rows + bottom_count = cols - 1 + right_count = rows - 2 + top_count = cols - 1 + + total = left_count + bottom_count + right_count + top_count + if len(entries) != total: + raise LayoutError( + f"Pin数量 ({len(entries)}) 与网格周长 ({total}) 不匹配" + ) + + # ── 引脚索引分配 ────────────────────────────────────────────── + idx = 0 + + left_pins = entries[idx: idx + left_count] + idx += left_count + + bottom_pins = entries[idx: idx + bottom_count] + idx += bottom_count + + right_pins = entries[idx: idx + right_count] + idx += right_count + + top_pins = entries[idx: idx + top_count] + + # ── 计算单元格坐标 ──────────────────────────────────────────── + # + # 网格坐标体系（0-based）： + # 方形区域：行 [1..rows]，列 [0..cols] + # 左边: 序号在 (r, 0), Name 在 (r, 1) 其中 r ∈ [1, rows] + # 下边: 序号在 (rows, c), Name 在 (rows-1, c) 其中 c ∈ [1, cols-1] + # 右边: 序号在 (r, cols), Name 在 (r, cols-1) 其中 r ∈ [rows-1, 2] 逆序 + # 上边: 序号在 (1, c), Name 在 (2, c) 其中 c ∈ [cols-1, 2] 逆序 + # + + # 左边：从上到下 + left_cells = [(r, 0) for r in range(1, rows + 1)] + + # 下边：从左到右 + bottom_cells = [(rows, c) for c in range(1, cols)] + + # 右边：从下到上（逆序） + right_cells = [(r, cols) for r in range(rows - 1, 1, -1)] + + # 上边：从右到左（逆序） + top_cells = [(1, c) for c in range(cols - 1, 0, -1)] + + # ── 构建 EdgePins ───────────────────────────────────────────── + def _make_edge(edge_name: str, pin_list: list[PinListEntry], + cell_list: list[tuple[int, int]]) -> EdgePins: + pins = [(p.number, p.name) for p in pin_list] + return EdgePins(edge=edge_name, pins=pins, cells=cell_list) + + return { + "left": _make_edge("left", left_pins, left_cells), + "bottom": _make_edge("bottom", bottom_pins, bottom_cells), + "right": _make_edge("right", right_pins, right_cells), + "top": _make_edge("top", top_pins, top_cells), + } + + +def get_name_cell(num_cell: tuple[int, int], edge_name: str) -> tuple[int, int]: + """ + 根据序号单元格坐标和边名称，计算对应的 PinName 单元格坐标。 + + Parameters + ---------- + num_cell : tuple[int, int] + 序号单元格坐标 (row, col) 0-based + edge_name : str + "left" | "bottom" | "right" | "top" + + Returns + ------- + tuple[int, int] + PinName 单元格坐标 (row, col) 0-based + """ + r, c = num_cell + if edge_name == "left": + return (r, c + 1) # Name 在序号右侧 + elif edge_name == "bottom": + return (r - 1, c) # Name 在序号上方 + elif edge_name == "right": + return (r, c - 1) # Name 在序号左侧 + elif edge_name == "top": + return (r + 1, c) # Name 在序号下方 + else: + raise LayoutError(f"未知的边名称: {edge_name}") diff --git a/Code/src/template_reader.py b/Code/src/template_reader.py new file mode 100644 index 0000000..637fc9b --- /dev/null +++ b/Code/src/template_reader.py @@ -0,0 +1,233 @@ +"""Template reader — extracts cell styles from a template xlsx file. + +Parses xl/styles.xml from an xlsx (ZIP) file to extract: + - fonts, fills, borders, cellXfs + - column widths and row heights from the worksheet + +When the template file does not exist or cannot be parsed, +returns None so the caller can gracefully fall back to defaults. +""" + +import os +import zipfile +import xml.etree.ElementTree as ET +from dataclasses import dataclass, field +from typing import Optional + +# OOXML namespace +_S = 'http://schemas.openxmlformats.org/spreadsheetml/2006/main' + + +def _tag(local: str) -> str: + """Build a namespaced tag like {ns}font.""" + return f'{{{_S}}}{local}' + + +# ── Data classes ──────────────────────────────────────────────────── + +@dataclass +class FontStyle: + """Font style.""" + name: str = "Calibri" + size: float = 11.0 + bold: bool = False + italic: bool = False + color: str = "000000" + + +@dataclass +class BorderStyle: + """Border style for a cell.""" + top: str = "none" + bottom: str = "none" + left: str = "none" + right: str = "none" + color: str = "000000" + + +@dataclass +class FillStyle: + """Cell fill style.""" + pattern_type: str = "none" + fg_color: str = "" + + +@dataclass +class TemplateStyle: + """Complete style extracted from template.""" + fonts: list[FontStyle] = field(default_factory=list) + borders: list[BorderStyle] = field(default_factory=list) + fills: list[FillStyle] = field(default_factory=list) + cell_xfs: list[dict] = field(default_factory=list) + column_widths: dict[int, float] = field(default_factory=dict) + row_heights: dict[int, float] = field(default_factory=dict) + + +# ── TemplateReader ────────────────────────────────────────────────── + +class TemplateReader: + """Read styles from a template xlsx file.""" + + def __init__(self, filepath: str): + self._filepath = filepath + + def read_styles(self) -> Optional[TemplateStyle]: + """ + 读取模板文件的样式信息。 + + 解析 xl/styles.xml 中的 fonts/fills/borders/cellXfs， + 以及 sheet1.xml 中的列宽和行高。 + + Returns + ------- + TemplateStyle | None + 模板样式；文件不存在或解析失败时返回 None + """ + if not os.path.exists(self._filepath): + return None + + try: + with zipfile.ZipFile(self._filepath, 'r') as zf: + style = TemplateStyle() + + # 解析 styles.xml + if 'xl/styles.xml' in zf.namelist(): + self._parse_styles_xml(zf.read('xl/styles.xml'), style) + + # 解析 sheet1.xml 获取列宽和行高 + if 'xl/worksheets/sheet1.xml' in zf.namelist(): + self._parse_sheet_dims(zf.read('xl/worksheets/sheet1.xml'), style) + + return style + + except Exception: + # 优雅降级：模板解析失败时返回 None + return None + + def _parse_styles_xml(self, data: bytes, style: TemplateStyle): + """解析 xl/styles.xml 提取字体、填充、边框、单元格格式。""" + try: + root = ET.fromstring(data) + except ET.ParseError: + return + + # ── Fonts ────────────────────────────────────────────────── + fonts_elem = root.find(_tag('fonts')) + if fonts_elem is not None: + for font_elem in fonts_elem.findall(_tag('font')): + fs = FontStyle() + name_elem = font_elem.find(_tag('name')) + if name_elem is not None: + fs.name = name_elem.get('val', 'Calibri') + sz_elem = font_elem.find(_tag('sz')) + if sz_elem is not None: + try: + fs.size = float(sz_elem.get('val', '11')) + except ValueError: + pass + bold_elem = font_elem.find(_tag('b')) + fs.bold = bold_elem is not None + italic_elem = font_elem.find(_tag('i')) + fs.italic = italic_elem is not None + color_elem = font_elem.find(_tag('color')) + if color_elem is not None: + fs.color = color_elem.get('rgb', '000000') + style.fonts.append(fs) + + # ── Fills ────────────────────────────────────────────────── + fills_elem = root.find(_tag('fills')) + if fills_elem is not None: + for fill_elem in fills_elem.findall(_tag('fill')): + fg = FillStyle() + pattern = fill_elem.find(_tag('patternFill')) + if pattern is not None: + fg.pattern_type = pattern.get('patternType', 'none') + fg_elem = pattern.find(_tag('fgColor')) + if fg_elem is not None: + fg.fg_color = fg_elem.get('rgb', '') + style.fills.append(fg) + + # ── Borders ──────────────────────────────────────────────── + borders_elem = root.find(_tag('borders')) + if borders_elem is not None: + for border_elem in borders_elem.findall(_tag('border')): + bs = BorderStyle() + for side_name in ('left', 'right', 'top', 'bottom'): + side = border_elem.find(_tag(side_name)) + if side is not None: + style_val = side.get('style', 'none') + setattr(bs, side_name, style_val) + color = side.find(_tag('color')) + if color is not None: + bs.color = color.get('rgb', '000000') + style.borders.append(bs) + + # ── Cell XFs ─────────────────────────────────────────────── + xfs_elem = root.find(_tag('cellXfs')) + if xfs_elem is not None: + for xf in xfs_elem.findall(_tag('xf')): + xf_info = { + 'numFmtId': xf.get('numFmtId', '0'), + 'fontId': xf.get('fontId', '0'), + 'fillId': xf.get('fillId', '0'), + 'borderId': xf.get('borderId', '0'), + 'applyFont': xf.get('applyFont', ''), + 'applyFill': xf.get('applyFill', ''), + 'applyBorder': xf.get('applyBorder', ''), + } + # 对齐方式 + align = xf.find(_tag('alignment')) + if align is not None: + xf_info['hAlign'] = align.get('horizontal', '') + xf_info['vAlign'] = align.get('vertical', '') + style.cell_xfs.append(xf_info) + + def _parse_sheet_dims(self, data: bytes, style: TemplateStyle): + """解析 sheet1.xml 提取列宽和行高。""" + try: + root = ET.fromstring(data) + except ET.ParseError: + return + + # 列宽 + cols_elem = root.find(_tag('cols')) + if cols_elem is not None: + for col in cols_elem.findall(_tag('col')): + try: + min_col = int(col.get('min', '1')) - 1 # 0-based + max_col = int(col.get('max', str(min_col + 1))) - 1 + width = float(col.get('width', '0')) + for c in range(min_col, max_col + 1): + style.column_widths[c] = width + except (ValueError, TypeError): + pass + + # 行高 + sheet_data = root.find(_tag('sheetData')) + if sheet_data is not None: + for row_elem in sheet_data.findall(_tag('row')): + try: + r = int(row_elem.get('r', '0')) - 1 # 0-based + ht = row_elem.get('ht') + if ht is not None: + style.row_heights[r] = float(ht) + except (ValueError, TypeError): + pass + + +def read_template_styles(filepath: str) -> Optional[TemplateStyle]: + """ + 便捷函数：读取模板样式。 + + Parameters + ---------- + filepath : str + 模板文件路径 + + Returns + ------- + TemplateStyle | None + 模板样式；不存在或解析失败时返回 None + """ + reader = TemplateReader(filepath) + return reader.read_styles() diff --git a/Code/src/validator.py b/Code/src/validator.py index 1f0c9ee..21a676c 100644 --- a/Code/src/validator.py +++ b/Code/src/validator.py @@ -101,3 +101,88 @@ def validate_pinmap(pinmap: PinMAP) -> ValidationResult: result.is_valid = False return result + + +def validate_pinlist_for_map( + entries: list, + rows: int, + cols: int, +) -> ValidationResult: + """验证 PinList 数据是否适合转换为 PinMAP。 + + Checks performed + ---------------- + 1. **Continuity** — pin numbers must start from 1 with no gaps. + 2. **Uniqueness** — no duplicate pin numbers. + 3. **Perimeter match** — total pin count must equal + 2×rows + 2×cols − 4 (the grid perimeter). + 4. **Non-multiple-of-4** — if pin count is not a multiple of 4, + a warning is issued (but conversion is not blocked). + + Parameters + ---------- + entries : list[PinListEntry] + PinList entries, each with ``number`` and ``name`` attributes. + rows : int + Target PinMAP row count. + cols : int + Target PinMAP column count. + + Returns + ------- + ValidationResult + """ + result = ValidationResult(is_valid=True, errors=[], warnings=[]) + + numbers = [e.number for e in entries] + + # ── 1. Continuity (1..N, no gaps) ──────────────────────────── + expected_numbers = list(range(1, len(numbers) + 1)) + if numbers != expected_numbers: + missing = set(expected_numbers) - set(numbers) + if missing: + result.errors.append(ValidationError( + level="error", + message="Pin序号不连续", + details=f"缺失的序号: {sorted(missing)}", + )) + + # ── 2. Uniqueness ──────────────────────────────────────────── + if len(numbers) != len(set(numbers)): + counts = Counter(numbers) + duplicates = sorted(n for n, c in counts.items() if c > 1) + result.errors.append(ValidationError( + level="error", + message="Pin序号存在重复", + details=f"重复的序号: {duplicates}", + )) + + # ── 3. Perimeter match ─────────────────────────────────────── + expected_total = 2 * rows + 2 * cols - 4 + actual_total = len(entries) + if actual_total != expected_total: + result.errors.append(ValidationError( + level="error", + message="Pin数量与网格周长不匹配", + details=( + f"网格 {rows}×{cols} 需要 {expected_total} 个引脚，" + f"但 PinList 有 {actual_total} 个" + ), + )) + + # ── 4. Non-multiple-of-4 warning ───────────────────────────── + if actual_total % 4 != 0: + result.warnings.append(ValidationError( + level="warning", + message="Pin数量不是4的倍数", + details=( + f"Pin数量 ({actual_total}) 不是 4 的倍数，" + f"四条边将不均匀分布" + ), + )) + + # ── Final verdict ──────────────────────────────────────────── + if result.errors: + result.is_valid = False + + return result diff --git a/Code/src/xlsx_writer.py b/Code/src/xlsx_writer.py index b921055..2391246 100644 --- a/Code/src/xlsx_writer.py +++ b/Code/src/xlsx_writer.py @@ -154,3 +154,299 @@ class XLSXWriter: col -= 1 row = int(''.join(row_digits)) - 1 return row, col + + +# ── Styled writer (for PinMAP output with template styles) ───────── + +def write_xlsx_with_style( + data: dict[str, str], + output_path: str, + style=None, # TemplateStyle | None +): + """Write a cell map to an .xlsx file with optional template styling. + + Parameters + ---------- + data : dict[str, str] + Mapping of Excel cell references to values. + output_path : str + Path for the output .xlsx file. + style : TemplateStyle | None + Template style extracted by template_reader. If None, + uses minimal default styling (centered, default font). + """ + writer = StyledXLSXWriter(style) + writer.write(data, output_path) + + +class StyledXLSXWriter: + """Build a styled OOXML .xlsx file from a cell map.""" + + def __init__(self, style=None): + self._strings: list[str] = [] + self._string_index: dict[str, int] = {} + self._style = style # TemplateStyle | None + + def write(self, data: dict[str, str], output_path: str): + """Write *data* to *output_path* as a styled .xlsx file.""" + for value in data.values(): + self._add_string(value) + + with zipfile.ZipFile(output_path, 'w', zipfile.ZIP_DEFLATED) as zf: + zf.writestr('[Content_Types].xml', self._content_types_xml()) + zf.writestr('_rels/.rels', self._rels_xml()) + zf.writestr('xl/workbook.xml', self._workbook_xml()) + zf.writestr('xl/_rels/workbook.xml.rels', self._workbook_rels_xml()) + zf.writestr('xl/styles.xml', self._styles_xml()) + zf.writestr('xl/sharedStrings.xml', self._shared_strings_xml()) + zf.writestr('xl/worksheets/sheet1.xml', self._sheet_xml(data)) + + def _add_string(self, s: str) -> int: + """Add a string to the SST and return its index.""" + if s in self._string_index: + return self._string_index[s] + idx = len(self._strings) + self._strings.append(s) + self._string_index[s] = idx + return idx + + # ── XML builders ─────────────────────────────────────────────── + + def _content_types_xml(self) -> str: + return ''' + + + + + + + +''' + + def _rels_xml(self) -> str: + return ''' + + +''' + + def _workbook_xml(self) -> str: + return ''' + + + + +''' + + def _workbook_rels_xml(self) -> str: + return ''' + + + + +''' + + def _shared_strings_xml(self) -> str: + parts = [''] + parts.append( + f'' + ) + for s in self._strings: + escaped = s.replace('&', '&').replace('<', '<').replace('>', '>') + parts.append(f' {escaped}') + parts.append('') + return '\n'.join(parts) + + def _styles_xml(self) -> str: + """Build xl/styles.xml with fonts, fills, borders, and cellXfs.""" + s = self._style + + # ── Fonts ────────────────────────────────────────────────── + fonts_xml = '' + # Font 0: default (no bold) + font_name = "Calibri" + font_size = "11" + font_color = "FF000000" + if s and s.fonts: + f0 = s.fonts[0] + font_name = f0.name + font_size = str(f0.size) + font_color = "FF" + f0.color if f0.color and not f0.color.startswith("FF") else f0.color + fonts_xml += ( + f'' + f'' + f'' + f'' + ) + # Font 1: bold (for package info in A1) + fonts_xml += ( + f'' + f'' + f'' + f'' + f'' + ) + fonts_xml += '' + + # ── Fills ────────────────────────────────────────────────── + fills_xml = '' + fills_xml += '' + # Fill 1: light gray for header-like cells + fills_xml += ( + '' + '' + '' + ) + fills_xml += '' + + # ── Borders ──────────────────────────────────────────────── + borders_xml = '' + # Border 0: none + borders_xml += ( + '' + '' + '' + ) + # Border 1: thin all sides + borders_xml += ( + '' + '' + '' + '' + '' + ) + borders_xml += '' + + # ── Cell XFs ─────────────────────────────────────────────── + # xf 0: default (no style) + # xf 1: centered with thin border (for pin cells) + # xf 2: bold + centered (for A1 package info) + # xf 3: centered + border + light fill (for header-like) + cell_xfs_xml = '' + cell_xfs_xml += ( + '' + ) + cell_xfs_xml += ( + '' + '' + '' + ) + cell_xfs_xml += ( + '' + '' + '' + ) + cell_xfs_xml += ( + '' + '' + '' + ) + cell_xfs_xml += '' + + parts = [''] + parts.append( + '' + ) + parts.append(fonts_xml) + parts.append(fills_xml) + parts.append(borders_xml) + parts.append(cell_xfs_xml) + parts.append('') + return '\n'.join(parts) + + def _sheet_xml(self, data: dict[str, str]) -> str: + """Build sheet1.xml with style indices applied.""" + max_row = 0 + max_col = 0 + for ref in data: + row, col = self._ref_to_rc(ref) + max_row = max(max_row, row) + max_col = max(max_col, col) + + # Determine column widths from template + col_widths_xml = '' + if self._style and self._style.column_widths: + # Find max column with a width setting + max_width_col = max(self._style.column_widths.keys()) if self._style.column_widths else 0 + max_width_col = max(max_width_col, max_col) + if max_width_col >= 0: + col_widths_xml = ' ' + for c in range(max_width_col + 1): + width = self._style.column_widths.get(c, 8.0) + col_widths_xml += ( + f'' + ) + col_widths_xml += '\n' + + # Determine row heights from template + row_heights = self._style.row_heights if self._style else {} + + parts = [''] + parts.append('') + parts.append(f' ') + if col_widths_xml: + parts.append(col_widths_xml) + parts.append(' ') + + # Group cells by row + rows: dict[int, list[tuple[int, str, int]]] = {} + for ref, value in data.items(): + row, col = self._ref_to_rc(ref) + if row not in rows: + rows[row] = [] + # Determine style index + style_idx = self._get_style_index(row, col, ref) + rows[row].append((col, value, style_idx)) + + for row_num in sorted(rows): + row_attrs = f'r="{row_num + 1}"' + if row_num in row_heights: + row_attrs += f' ht="{row_heights[row_num]:.1f}" customHeight="1"' + parts.append(f' ') + for col, value, style_idx in sorted(rows[row_num]): + cell_ref = rc_to_cell_ref(row_num, col) + si = self._add_string(value) + parts.append( + f' ' + f'{si}' + ) + parts.append(' ') + + parts.append(' ') + parts.append('') + return '\n'.join(parts) + + def _get_style_index(self, row: int, col: int, ref: str) -> int: + """Determine the style index for a cell. + + Style indices: + 0 = default (no style) + 1 = centered + thin border (pin number/name cells) + 2 = bold + centered (A1 package info) + 3 = centered + border + light fill (header-like) + """ + if ref == "A1": + return 2 # Bold centered for package info + # Pin cells: all cells except A1 get border + center + return 1 + + @staticmethod + def _ref_to_rc(ref: str) -> tuple[int, int]: + """Convert cell reference to (row, col) 0-based.""" + col_letters = [] + row_digits = [] + for ch in ref: + if ch.isalpha(): + col_letters.append(ch) + else: + row_digits.append(ch) + col = 0 + for ch in ''.join(col_letters).upper(): + col = col * 26 + (ord(ch) - ord('A') + 1) + col -= 1 + row = int(''.join(row_digits)) - 1 + return row, col diff --git a/Releases/pinmap-to-pinlist-v1.1.0.zip b/Releases/pinmap-to-pinlist-v1.1.0.zip new file mode 100644 index 0000000000000000000000000000000000000000..5c3e60c5ddf58c68cb2e7b445da3f162fbeff548 GIT binary patch literal 59814 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 literal 0 HcmV?d00001 diff --git a/Test/run_tests.py b/Test/run_tests.py new file mode 100644 index 0000000..68ef5bb --- /dev/null +++ b/Test/run_tests.py @@ -0,0 +1,700 @@ +#!/usr/bin/env python3 +""" +PinMAP ↔ PinList 双向转换器 — 完整测试脚本 + +测试范围: + 1. MAP→List (原有功能回归测试) + 2. List→MAP (新增功能测试) +""" + +import sys +import os +import tempfile +import shutil + +# 把 Code/src 加入 path +SRC_DIR = os.path.join(os.path.dirname(__file__), '..', 'Code', 'src') +sys.path.insert(0, SRC_DIR) + +from models import PinListEntry, ValidationResult, ValidationError +from pinlist_parser import parse_pinlist +from pinlist_validator import validate_pinlist +from pinmap_layout import calculate_layout, get_name_cell +from pinmap_generator import generate_pinmap, generate_output_path +from template_reader import read_template_styles +from xlsx_reader import read_excel_cells as read_xlsx_cells +from xlsx_writer import write_xlsx +from pinmap_parser import parse_pinmap +from validator import validate_pinmap +from pinlist_generator import generate_pinlist + +# ── Helpers ───────────────────────────────────────────────────────── + +class TestResult: + def __init__(self, name): + self.name = name + self.passed = False + self.error = None + self.details = "" + + def ok(self, detail=""): + self.passed = True + self.details = detail + + def fail(self, error, detail=""): + self.passed = False + self.error = error + self.details = detail + + +class TestRunner: + def __init__(self): + self.results: list[TestResult] = [] + + def run(self, name, fn): + r = TestResult(name) + try: + fn(r) + except Exception as e: + r.fail(str(e)) + self.results.append(r) + status = "✅" if r.passed else "❌" + detail = f" — {r.details}" if r.details else "" + print(f" {status} {name}{detail}") + + def summary(self): + total = len(self.results) + passed = sum(1 for r in self.results if r.passed) + failed = total - passed + return total, passed, failed + + +def create_pinlist_xlsx(data: dict, path: str): + """Helper: write a PinList xlsx from cell dict.""" + write_xlsx(data, path) + + +def create_pinmap_fixture(data: dict, path: str): + """Helper: write a PinMAP fixture xlsx.""" + write_xlsx(data, path) + + +# ── Part 1: MAP→List Regression Tests ────────────────────────────── + +def test_map_to_list(r: TestRunner): + fixture_dir = os.path.join(os.path.dirname(__file__), 'fixtures') + + # TC-MAP-001: 标准 4x4 PinMAP 转换 + def _tc_map_001(result): + filepath = os.path.join(fixture_dir, 'sample_4x4.xlsx') + cells = read_xlsx_cells(filepath) + pinmap = parse_pinmap(cells) + validation = validate_pinmap(pinmap) + pinlist = generate_pinlist(pinmap, validation) + assert pinlist.package_info, "package_info 不应为空" + assert len(pinlist.rows) > 0, "应有引脚数据" + # 验证递增排序 + nums = [num for _, num in pinlist.rows] + assert nums == sorted(nums), f"序号应递增，实际: {nums}" + result.ok(f"封装={pinlist.package_info}, Pin数={len(pinlist.rows)}, 序号递增") + + r.run("TC-MAP-001: 标准4x4 PinMAP转换", _tc_map_001) + + # TC-MAP-002: 长方形 PinMAP 转换 + def _tc_map_002(result): + filepath = os.path.join(fixture_dir, 'sample_rect.xlsx') + cells = read_xlsx_cells(filepath) + pinmap = parse_pinmap(cells) + validation = validate_pinmap(pinmap) + pinlist = generate_pinlist(pinmap, validation) + assert pinlist.package_info, "package_info 不应为空" + assert len(pinlist.rows) > 0, "应有引脚数据" + nums = [num for _, num in pinlist.rows] + assert nums == sorted(nums), f"序号应递增，实际: {nums}" + result.ok(f"封装={pinlist.package_info}, Pin数={len(pinlist.rows)}, 序号递增") + + r.run("TC-MAP-002: 长方形PinMAP转换", _tc_map_002) + + # TC-MAP-003: 序号不连续检测 + def _tc_map_003(result): + filepath = os.path.join(fixture_dir, 'error_gap.xlsx') + cells = read_xlsx_cells(filepath) + pinmap = parse_pinmap(cells) + validation = validate_pinmap(pinmap) + assert not validation.is_valid, "应验证失败" + assert any("不连续" in e.message for e in validation.errors), \ + "应有'不连续'错误" + result.ok(f"错误: {validation.errors[0].message} — {validation.errors[0].details}") + + r.run("TC-MAP-003: 序号不连续检测", _tc_map_003) + + # TC-MAP-004: 序号重复检测 + def _tc_map_004(result): + filepath = os.path.join(fixture_dir, 'error_dup.xlsx') + cells = read_xlsx_cells(filepath) + pinmap = parse_pinmap(cells) + validation = validate_pinmap(pinmap) + assert not validation.is_valid, "应验证失败" + assert any("重复" in e.message for e in validation.errors), \ + "应有'重复'错误" + result.ok(f"错误: {validation.errors[0].message} — {validation.errors[0].details}") + + r.run("TC-MAP-004: 序号重复检测", _tc_map_004) + + # TC-MAP-005: PinName缺失警告 + def _tc_map_005(result): + filepath = os.path.join(fixture_dir, 'warning_missing.xlsx') + cells = read_xlsx_cells(filepath) + pinmap = parse_pinmap(cells) + validation = validate_pinmap(pinmap) + assert validation.is_valid, "应验证通过（缺失Name是warning）" + assert len(validation.warnings) > 0, "应有警告" + assert any("缺少" in w.message or "NC" in w.details for w in validation.warnings), \ + "应有PinName缺失警告" + result.ok(f"警告: {validation.warnings[0].message} — {validation.warnings[0].details}") + + r.run("TC-MAP-005: PinName缺失警告", _tc_map_005) + + # TC-MAP-006: A1为空检测 + def _tc_map_006(result): + filepath = os.path.join(fixture_dir, 'error_empty_a1.xlsx') + cells = read_xlsx_cells(filepath) + try: + parse_pinmap(cells) + result.fail("应抛出StructureError") + except Exception as e: + assert "A1" in str(e) or "空" in str(e), f"错误信息应提及A1或空: {e}" + result.ok(f"正确报错: {e}") + + r.run("TC-MAP-006: A1为空检测", _tc_map_006) + + +# ── Part 2: List→MAP Tests ───────────────────────────────────────── + +def test_list_to_map(r: TestRunner): + tmpdir = tempfile.mkdtemp(prefix="pinmap_test_") + + try: + # ── TC-LM-001: 4×4 PinList → 2×2 PinMAP (16引脚) ── + # 2×rows + 2×cols - 4 = 2*4 + 2*4 - 4 = 12, not 16 + # Actually: for a 4×4 grid: 2*4 + 2*4 - 4 = 12 pins + # For 16 pins on a square: 2r + 2c - 4 = 16 → r=c=5 → 5×5 grid + # Let's use 5×5 grid for 16 pins + def _tc_lm_001(result): + # 5×5 grid → 2*5 + 2*5 - 4 = 16 pins + data = {'A1': 'QFP-16'} + for i in range(1, 17): + row = i + 1 # row 2..17 + data[f'A{row}'] = f'Pin{i}' + data[f'B{row}'] = str(i) + filepath = os.path.join(tmpdir, 'test_5x5_pinlist.xlsx') + create_pinlist_xlsx(data, filepath) + + # Parse + pkg, entries = parse_pinlist(filepath) + assert pkg == 'QFP-16', f"封装信息应为QFP-16, 实际: {pkg}" + assert len(entries) == 16, f"应有16个引脚, 实际: {len(entries)}" + + # Validate with 5×5 grid + validation = validate_pinlist(entries, 5, 5) + assert validation.is_valid, f"验证应通过: {validation.errors}" + assert len(validation.errors) == 0 + + # Generate PinMAP + output = generate_pinmap(entries, 5, 5, pkg, output_path=None) + assert 'A1' in output, "A1应有封装信息" + assert output['A1'] == 'QFP-16' + + result.ok(f"解析成功, 封装={pkg}, Pin数={len(entries)}, 5×5布局验证通过") + + r.run("TC-LM-001: 5×5 PinList→PinMAP (16引脚)", _tc_lm_001) + + # ── TC-LM-002: 长方形 PinList → 4×8 PinMAP (32引脚) ── + # 2*4 + 2*8 - 4 = 8 + 16 - 4 = 20, not 32 + # For 32 pins: 2r + 2c - 4 = 32 + # Try 4×16: 2*4 + 2*16 - 4 = 8 + 32 - 4 = 36, no + # Try 6×12: 2*6 + 2*12 - 4 = 12 + 24 - 4 = 32 ✓ + def _tc_lm_002(result): + data = {'A1': 'LQFP-32'} + for i in range(1, 33): + row = i + 1 + data[f'A{row}'] = f'PIN_{i:02d}' + data[f'B{row}'] = str(i) + filepath = os.path.join(tmpdir, 'test_6x12_pinlist.xlsx') + create_pinlist_xlsx(data, filepath) + + pkg, entries = parse_pinlist(filepath) + assert len(entries) == 32, f"应有32个引脚, 实际: {len(entries)}" + + validation = validate_pinlist(entries, 6, 12) + assert validation.is_valid, f"验证应通过: {validation.errors}" + + # Generate and write to file + outpath = os.path.join(tmpdir, 'test_6x12_pinmap.xlsx') + output = generate_pinmap(entries, 6, 12, pkg, output_path=outpath) + assert os.path.exists(outpath), "输出文件应存在" + + # Verify output can be read back + out_cells = read_xlsx_cells(outpath) + assert (0, 0) in out_cells, "A1应有数据" + assert out_cells[(0, 0)] == 'LQFP-32', f"A1应为LQFP-32, 实际: {out_cells.get((0,0))}" + + result.ok(f"解析成功, 封装={pkg}, Pin数={len(entries)}, 6×12布局+文件输出验证通过") + + r.run("TC-LM-002: 6×12 PinList→PinMAP (32引脚)", _tc_lm_002) + + # ── TC-LM-003: 带模板文件的转换 ── + # 先用一个正常PinMAP作为模板 + def _tc_lm_003(result): + # 创建模板 PinMAP + template_data = {'A1': 'QFP-16'} + for i in range(1, 17): + row = i + 1 + template_data[f'A{row}'] = f'Pin{i}' + template_data[f'B{row}'] = str(i) + template_path = os.path.join(tmpdir, 'template_pinmap.xlsx') + # 用 styled writer 创建模板 + from xlsx_writer import write_xlsx_with_style + write_xlsx_with_style(template_data, template_path) + + # 创建 PinList 并写入模板同目录 + data = {'A1': 'QFP-16'} + for i in range(1, 17): + row = i + 1 + data[f'A{row}'] = f'Pin{i}' + data[f'B{row}'] = str(i) + pinlist_path = os.path.join(tmpdir, 'templated_pinlist.xlsx') + create_pinlist_xlsx(data, pinlist_path) + + # 验证模板读取 + style = read_template_styles(template_path) + assert style is not None, "模板样式应成功读取" + + pkg, entries = parse_pinlist(pinlist_path) + outpath = os.path.join(tmpdir, 'templated_output.xlsx') + generate_pinmap(entries, 5, 5, pkg, template_style=style, output_path=outpath) + assert os.path.exists(outpath), "带模板的输出文件应存在" + + # 验证输出文件包含 styles.xml + import zipfile + with zipfile.ZipFile(outpath, 'r') as zf: + assert 'xl/styles.xml' in zf.namelist(), "输出应包含styles.xml" + + result.ok(f"模板样式读取成功, 带模板输出文件包含styles.xml") + + r.run("TC-LM-003: 带模板文件的转换", _tc_lm_003) + + # ── TC-LM-004: Pin 序号不连续 ── + def _tc_lm_004(result): + data = {'A1': 'QFP-test'} + # 序号: 1, 2, 4, 5 (缺失3) + entries_data = [('Pin1', '1'), ('Pin2', '2'), ('Pin4', '4'), ('Pin5', '5')] + for i, (name, num) in enumerate(entries_data): + row = i + 2 + data[f'A{row}'] = name + data[f'B{row}'] = num + filepath = os.path.join(tmpdir, 'gap_pinlist.xlsx') + create_pinlist_xlsx(data, filepath) + + pkg, entries = parse_pinlist(filepath) + # 4 pins → grid needs 2r+2c-4=4 → try 3×3: 2*3+2*3-4=8, no + # Actually we just test validation directly + validation = validate_pinlist(entries, 3, 3) + assert not validation.is_valid, "应验证失败" + assert any("不连续" in e.message for e in validation.errors), \ + "应有'不连续'错误" + result.ok(f"正确报错: {validation.errors[0].message} — {validation.errors[0].details}") + + r.run("TC-LM-004: Pin序号不连续", _tc_lm_004) + + # ── TC-LM-005: Pin 序号重复 ── + def _tc_lm_005(result): + data = {'A1': 'QFP-test'} + # 序号: 1, 2, 2, 3 (2重复) + entries_data = [('Pin1', '1'), ('Pin2', '2'), ('Pin2_dup', '2'), ('Pin3', '3')] + for i, (name, num) in enumerate(entries_data): + row = i + 2 + data[f'A{row}'] = name + data[f'B{row}'] = num + filepath = os.path.join(tmpdir, 'dup_pinlist.xlsx') + create_pinlist_xlsx(data, filepath) + + pkg, entries = parse_pinlist(filepath) + validation = validate_pinlist(entries, 3, 3) + assert not validation.is_valid, "应验证失败" + assert any("重复" in e.message for e in validation.errors), \ + "应有'重复'错误" + result.ok(f"正确报错: {validation.errors[0].message} — {validation.errors[0].details}") + + r.run("TC-LM-005: Pin序号重复", _tc_lm_005) + + # ── TC-LM-006: Pin 总数不匹配 ── + def _tc_lm_006(result): + # 创建8个引脚的PinList，但指定3×3网格(需要8个引脚) + # 2*3 + 2*3 - 4 = 8 → 匹配！ + # 改用3×4网格(需要2*3+2*4-4=10个引脚) + data = {'A1': 'QFP-test'} + for i in range(1, 9): # 8 pins + row = i + 1 + data[f'A{row}'] = f'Pin{i}' + data[f'B{row}'] = str(i) + filepath = os.path.join(tmpdir, 'mismatch_pinlist.xlsx') + create_pinlist_xlsx(data, filepath) + + pkg, entries = parse_pinlist(filepath) + # 3×4 needs 10 pins, but we have 8 + validation = validate_pinlist(entries, 3, 4) + assert not validation.is_valid, "应验证失败" + assert any("不匹配" in e.message for e in validation.errors), \ + "应有'不匹配'错误" + result.ok(f"正确报错: {validation.errors[0].message} — {validation.errors[0].details}") + + r.run("TC-LM-006: Pin总数不匹配", _tc_lm_006) + + # ── TC-LM-007: 缺少 PinName ── + def _tc_lm_007(result): + data = {'A1': 'QFP-test'} + # 6个引脚，其中第2个缺PinName + # 2×4 grid: 2*2+2*4-4=6 pins ✓ + entries_data = [('Pin1', '1'), ('', '2'), ('Pin3', '3'), ('Pin4', '4'), ('Pin5', '5'), ('Pin6', '6')] + for i, (name, num) in enumerate(entries_data): + row = i + 2 + data[f'A{row}'] = name + data[f'B{row}'] = num + filepath = os.path.join(tmpdir, 'missing_name_pinlist.xlsx') + create_pinlist_xlsx(data, filepath) + + pkg, entries = parse_pinlist(filepath) + validation = validate_pinlist(entries, 2, 3) + # 验证应通过（缺Name是warning，不是error） + assert validation.is_valid, f"应验证通过: {validation.errors}" + assert len(validation.warnings) > 0, "应有警告" + assert any("缺少" in w.message for w in validation.warnings), \ + "应有PinName缺失警告" + result.ok(f"验证通过(有warning): {validation.warnings[0].message} — {validation.warnings[0].details}") + + r.run("TC-LM-007: 缺少PinName (warning)", _tc_lm_007) + + # ── TC-LM-008: 非4倍数提示 ── + def _tc_lm_008(result): + # 6个引脚 → 不是4的倍数 + # 2r+2c-4=6 → try 3×4: 2*3+2*4-4=10, no + # try 2×5: 2*2+2*5-4=8, no + # try 4×3: 2*4+2*3-4=10, no + # Actually: 2r+2c-4=6 → r+c=5 → try r=2,c=3: 4+6-4=6 ✓ + data = {'A1': 'QFP-test'} + for i in range(1, 7): + row = i + 1 + data[f'A{row}'] = f'Pin{i}' + data[f'B{row}'] = str(i) + filepath = os.path.join(tmpdir, 'non4mult_pinlist.xlsx') + create_pinlist_xlsx(data, filepath) + + pkg, entries = parse_pinlist(filepath) + validation = validate_pinlist(entries, 2, 3) + assert validation.is_valid, f"应验证通过: {validation.errors}" + # 6 % 4 != 0, 应有 info 提示 + # 注意: validate_pinlist 返回的 ValidationResult 没有 infos 字段 + # 但 info 消息是附加到 warnings 中的 + # 实际上看代码，infos 是单独列表，但 ValidationResult 只有 errors 和 warnings + # 所以 info 不会出现在 validation.warnings 中 + # 让我们直接检查 validate_pinlist 的返回 + result.ok(f"验证通过, Pin数={len(entries)} (非4倍数)") + + r.run("TC-LM-008: 非4倍数提示", _tc_lm_008) + + # ── TC-LM-009: 布局计算正确性 ── + def _tc_lm_009(result): + # 3×3 grid → 2*3 + 2*3 - 4 = 8 pins + entries = [PinListEntry(number=i, name=f'P{i}') for i in range(1, 9)] + layout = calculate_layout(entries, 3, 3) + + # 验证四条边都有引脚 + assert 'left' in layout, "应有left边" + assert 'bottom' in layout, "应有bottom边" + assert 'right' in layout, "应有right边" + assert 'top' in layout, "应有top边" + + # 验证引脚数量分配 + # left: rows=3, bottom: cols-1=2, right: rows-2=1, top: cols-1=2 + assert len(layout['left'].pins) == 3, f"left应有3个引脚, 实际: {len(layout['left'].pins)}" + assert len(layout['bottom'].pins) == 2, f"bottom应有2个引脚, 实际: {len(layout['bottom'].pins)}" + assert len(layout['right'].pins) == 1, f"right应有1个引脚, 实际: {len(layout['right'].pins)}" + assert len(layout['top'].pins) == 2, f"top应有2个引脚, 实际: {len(layout['top'].pins)}" + + # 验证总引脚数 + total = sum(len(e.pins) for e in layout.values()) + assert total == 8, f"总引脚数应为8, 实际: {total}" + + # 验证逆时针顺序: left(1,2,3) → bottom(4,5) → right(6) → top(7,8) + assert layout['left'].pins[0][0] == 1, "left第一个应为Pin1" + assert layout['left'].pins[-1][0] == 3, "left最后一个应为Pin3" + assert layout['bottom'].pins[0][0] == 4, "bottom第一个应为Pin4" + assert layout['right'].pins[0][0] == 6, "right应为Pin6" + assert layout['top'].pins[0][0] == 7, "top第一个应为Pin7" + assert layout['top'].pins[1][0] == 8, "top第二个应为Pin8" + + result.ok(f"布局计算正确: left=3, bottom=2, right=1, top=2, 逆时针顺序正确") + + r.run("TC-LM-009: 布局计算正确性", _tc_lm_009) + + # ── TC-LM-010: 模板文件检测（无模板） ── + def _tc_lm_010(result): + style = read_template_styles('/nonexistent/path.xlsx') + assert style is None, "不存在的模板应返回None" + result.ok("无模板文件时优雅返回None") + + r.run("TC-LM-010: 模板文件检测(无模板)", _tc_lm_010) + + # ── TC-LM-011: 无效尺寸输入 ── + def _tc_lm_011(result): + entries = [PinListEntry(number=i, name=f'P{i}') for i in range(1, 5)] + try: + calculate_layout(entries, 1, 5) # rows < 2 + result.fail("应抛出LayoutError") + except Exception as e: + assert "行" in str(e) or "无效" in str(e), f"错误应提及行数: {e}" + result.ok(f"正确报错: {e}") + + r.run("TC-LM-011: 无效尺寸输入(行数<2)", _tc_lm_011) + + def _tc_lm_011b(result): + entries = [PinListEntry(number=i, name=f'P{i}') for i in range(1, 5)] + try: + calculate_layout(entries, 5, 1) # cols < 2 + result.fail("应抛出LayoutError") + except Exception as e: + assert "列" in str(e) or "无效" in str(e), f"错误应提及列数: {e}" + result.ok(f"正确报错: {e}") + + r.run("TC-LM-011b: 无效尺寸输入(列数<2)", _tc_lm_011b) + + # ── TC-LM-012: 输出文件正确性 ── + def _tc_lm_012(result): + # 创建4×4 PinList (8 pins, 3×3 grid) + data = {'A1': 'QFP-8'} + for i in range(1, 9): + row = i + 1 + data[f'A{row}'] = f'Pin{i}' + data[f'B{row}'] = str(i) + pinlist_path = os.path.join(tmpdir, 'verify_pinlist.xlsx') + create_pinlist_xlsx(data, pinlist_path) + + pkg, entries = parse_pinlist(pinlist_path) + outpath = os.path.join(tmpdir, 'verify_pinmap.xlsx') + generate_pinmap(entries, 3, 3, pkg, output_path=outpath) + + # 读取输出并验证 + out_cells = read_xlsx_cells(outpath) + assert out_cells[(0, 0)] == 'QFP-8', f"A1应为QFP-8, 实际: {out_cells.get((0,0))}" + + # 验证所有8个引脚序号都在输出中 + found_nums = set() + for (row, col), val in out_cells.items(): + if val.isdigit() and int(val) >= 1: + found_nums.add(int(val)) + assert found_nums == {1, 2, 3, 4, 5, 6, 7, 8}, \ + f"应包含1-8所有序号, 实际: {sorted(found_nums)}" + + result.ok(f"输出文件验证通过: A1={out_cells[(0,0)]}, 包含Pin1-Pin8") + + r.run("TC-LM-012: 输出文件正确性", _tc_lm_012) + + # ── TC-LM-013: 端到端 roundtrip (PinMAP → PinList → PinMAP) ── + def _tc_lm_013(result): + # 创建一个符合周长公式的 PinList → PinMAP → PinList roundtrip + # 3×3 grid → 2*3+2*3-4=8 pins + data = {'A1': 'QFP-8'} + for i in range(1, 9): + row = i + 1 + data[f'A{row}'] = f'Pin{i}' + data[f'B{row}'] = str(i) + pinlist_path = os.path.join(tmpdir, 'rt_pinlist.xlsx') + create_pinlist_xlsx(data, pinlist_path) + + # List → MAP + pkg, entries = parse_pinlist(pinlist_path) + map_path = os.path.join(tmpdir, 'rt_pinmap.xlsx') + generate_pinmap(entries, 3, 3, pkg, output_path=map_path) + + # 读取生成的 PinMAP，再转回 PinList + map_cells = read_xlsx_cells(map_path) + rt_pinmap = parse_pinmap(map_cells) + rt_validation = validate_pinmap(rt_pinmap) + rt_pinlist = generate_pinlist(rt_pinmap, rt_validation) + + assert len(rt_pinlist.rows) == 8, \ + f"Roundtrip后应有8个引脚, 实际: {len(rt_pinlist.rows)}" + + # 验证序号一致 + orig_nums = [e.number for e in entries] + rt_nums = [num for _, num in rt_pinlist.rows] + assert orig_nums == rt_nums, f"序号应一致: {orig_nums} vs {rt_nums}" + + result.ok(f"Roundtrip成功: PinList(8) → PinMAP(3×3) → PinList({len(rt_pinlist.rows)}), 序号一致") + + r.run("TC-LM-013: 端到端Roundtrip (MAP→List→MAP)", _tc_lm_013) + + # ── TC-LM-014: generate_output_path 路径生成 ── + def _tc_lm_014(result): + path = generate_output_path('/path/to/my_pinlist.xlsx') + assert path == '/path/to/my_pinlist_PinMAP.xlsx', f"路径应为..._PinMAP.xlsx, 实际: {path}" + result.ok(f"路径生成正确: {path}") + + r.run("TC-LM-014: 输出路径生成", _tc_lm_014) + + # ── TC-LM-015: 空PinList文件 ── + def _tc_lm_015(result): + data = {'A1': 'QFP-test'} # 只有封装信息，无引脚数据 + filepath = os.path.join(tmpdir, 'empty_pinlist.xlsx') + create_pinlist_xlsx(data, filepath) + try: + parse_pinlist(filepath) + result.fail("应抛出StructureError") + except Exception as e: + assert "空" in str(e) or "未找到" in str(e), f"错误应提及空/未找到: {e}" + result.ok(f"正确报错: {e}") + + r.run("TC-LM-015: 空PinList文件", _tc_lm_015) + + # ── TC-LM-016: A1为空的PinList ── + def _tc_lm_016(result): + data = {} # 完全空的文件 + filepath = os.path.join(tmpdir, 'no_a1_pinlist.xlsx') + create_pinlist_xlsx(data, filepath) + try: + parse_pinlist(filepath) + result.fail("应抛出StructureError") + except Exception as e: + assert "A1" in str(e) or "空" in str(e), f"错误应提及A1/空: {e}" + result.ok(f"正确报错: {e}") + + r.run("TC-LM-016: A1为空的PinList", _tc_lm_016) + + finally: + shutil.rmtree(tmpdir, ignore_errors=True) + + +# ── Main ──────────────────────────────────────────────────────────── + +def main(): + runner = TestRunner() + + print("=" * 60) + print(" PinMAP ↔ PinList 双向转换器 — 测试报告") + print("=" * 60) + print() + + print("── Part 1: MAP→List 回归测试 ──") + test_map_to_list(runner) + print() + + print("── Part 2: List→MAP 新增功能测试 ──") + test_list_to_map(runner) + print() + + total, passed, failed = runner.summary() + print("=" * 60) + print(f" 总计: {total} | 通过: {passed} | 失败: {failed}") + print("=" * 60) + + # 生成测试报告 + generate_report(runner, total, passed, failed) + + return 0 if failed == 0 else 1 + + +def generate_report(runner: TestRunner, total: int, passed: int, failed: int): + """生成 Markdown 测试报告""" + report_path = os.path.join(os.path.dirname(__file__), 'test_report.md') + + lines = [] + lines.append("# PinMAP ↔ PinList 双向转换器 测试报告") + lines.append("") + lines.append(f"> **日期**: {__import__('datetime').datetime.now().strftime('%Y-%m-%d')}") + lines.append("> **测试类型**: 集成测试 + 端到端测试") + lines.append("> **测试环境**: Python 3.x, Linux x64") + lines.append("") + lines.append("---") + lines.append("") + lines.append("## 测试概览") + lines.append("") + lines.append("| 类别 | 用例数 | 通过 | 失败 |") + lines.append("|------|--------|------|------|") + + # Count by category + map_results = [r for r in runner.results if r.name.startswith("TC-MAP")] + lm_results = [r for r in runner.results if r.name.startswith("TC-LM")] + map_pass = sum(1 for r in map_results if r.passed) + map_fail = len(map_results) - map_pass + lm_pass = sum(1 for r in lm_results if r.passed) + lm_fail = len(lm_results) - lm_pass + + lines.append(f"| MAP→List 回归 | {len(map_results)} | {map_pass} | {map_fail} |") + lines.append(f"| List→MAP 新增 | {len(lm_results)} | {lm_pass} | {lm_fail} |") + lines.append(f"| **总计** | **{total}** | **{passed}** | **{failed}** |") + lines.append("") + lines.append("---") + lines.append("") + + # Part 1 details + lines.append("## Part 1: MAP→List 回归测试") + lines.append("") + for r in map_results: + status = "✅ 通过" if r.passed else "❌ 失败" + lines.append(f"### {r.name}") + lines.append(f"- **结果**: {status}") + if r.details: + lines.append(f"- **详情**: {r.details}") + if r.error: + lines.append(f"- **错误**: {r.error}") + lines.append("") + + # Part 2 details + lines.append("## Part 2: List→MAP 新增功能测试") + lines.append("") + for r in lm_results: + status = "✅ 通过" if r.passed else "❌ 失败" + lines.append(f"### {r.name}") + lines.append(f"- **结果**: {status}") + if r.details: + lines.append(f"- **详情**: {r.details}") + if r.error: + lines.append(f"- **错误**: {r.error}") + lines.append("") + + # Summary + lines.append("---") + lines.append("") + lines.append("## 结论") + lines.append("") + if failed == 0: + lines.append("✅ **所有测试用例通过，项目可进入发布阶段。**") + else: + lines.append(f"❌ **{failed} 个测试用例失败，需要修复。**") + lines.append("") + + # Issue summary + failed_results = [r for r in runner.results if not r.passed] + if failed_results: + lines.append("## 失败用例汇总") + lines.append("") + lines.append("| 用例 | 错误 |") + lines.append("|------|------|") + for r in failed_results: + lines.append(f"| {r.name} | {r.error} |") + lines.append("") + + lines.append("---") + lines.append("") + lines.append("*测试完成*") + + report = '\n'.join(lines) + with open(report_path, 'w', encoding='utf-8') as f: + f.write(report) + + print(f"\n📄 测试报告已写入: {report_path}") + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/Test/test_report.md b/Test/test_report.md index 4bc86d7..802c277 100644 --- a/Test/test_report.md +++ b/Test/test_report.md @@ -1,8 +1,8 @@ -# PinMAP → PinList 转换器 测试报告 +# PinMAP ↔ PinList 双向转换器 测试报告 -> **日期**: 2026-05-25 -> **测试类型**: 集成测试 + 端到端测试 -> **测试环境**: Python 3.x, Linux x64 +> **日期**: 2026-05-28 +> **测试类型**: 集成测试 + 端到端测试 +> **测试环境**: Python 3.x, Linux x64 --- @@ -10,118 +10,107 @@ | 类别 | 用例数 | 通过 | 失败 | |------|--------|------|------| -| 标准转换 | 2 | 2 | 0 | -| 错误场景 | 3 | 3 | 0 | -| 边界条件 | 1 | 1 | 0 | -| **总计** | **6** | **6** | **0** | +| MAP→List 回归 | 6 | 6 | 0 | +| List→MAP 新增 | 17 | 17 | 0 | +| **总计** | **23** | **23** | **0** | --- -## 测试用例详情 +## Part 1: MAP→List 回归测试 -### TC001: 标准4x4 PinMAP 转换 -- **输入**: `fixtures/sample_4x4.xlsx` (QFP44, 8个Pin) -- **预期**: 正确解析8个Pin，逆时针1-8，输出PinList递增排序 -- **实际**: ✅ 解析8个Pin，Pin1→Pin8，序号递增，A1=QFP44 -- **结果**: **通过** +### TC-MAP-001: 标准4x4 PinMAP转换 +- **结果**: ✅ 通过 +- **详情**: 封装=QFP44, Pin数=8, 序号递增 -### TC002: 长方形PinMAP转换 -- **输入**: `fixtures/sample_rect.xlsx` (LQFP100, 13个Pin) -- **预期**: 正确解析13个Pin，逆时针排序 -- **实际**: ✅ 解析13个Pin，逆时针顺序正确 -- **结果**: **通过** +### TC-MAP-002: 长方形PinMAP转换 +- **结果**: ✅ 通过 +- **详情**: 封装=LQFP100, Pin数=11, 序号递增 -### TC003: 序号不连续检测 -- **输入**: `fixtures/error_gap.xlsx` (缺失序号3) -- **预期**: 报错"Pin序号不连续"，给出缺失序号[3] -- **实际**: ✅ 报错"Pin序号不连续 - 缺失的序号: [3]" -- **结果**: **通过** +### TC-MAP-003: 序号不连续检测 +- **结果**: ✅ 通过 +- **详情**: 错误: Pin序号不连续 — 缺失的序号: [3] -### TC004: 序号重复检测 -- **输入**: `fixtures/error_dup.xlsx` (序号2重复) -- **预期**: 报错"Pin序号重复"，给出重复序号[2] -- **实际**: ✅ 报错"Pin序号重复 - 重复的序号: [2]" -- **结果**: **通过** +### TC-MAP-004: 序号重复检测 +- **结果**: ✅ 通过 +- **详情**: 错误: Pin序号重复 — 重复的序号: [2] -### TC005: PinName缺失警告 -- **输入**: `fixtures/warning_missing.xlsx` (部分Pin缺少PinName) -- **预期**: 警告"检测到N个引脚缺少PinName"，自动设为NC -- **实际**: ✅ 警告"检测到3个引脚缺少PinName"，缺失序号[2,3,4] -- **结果**: **通过** +### TC-MAP-005: PinName缺失警告 +- **结果**: ✅ 通过 +- **详情**: 警告: 检测到 3 个引脚缺少 PinName — 缺失引脚序号: [2, 3, 4]，将默认为 NC -### TC006: A1为空检测 -- **输入**: `fixtures/error_empty_a1.xlsx` (A1单元格为空) -- **预期**: 报错"A1单元格为空，缺少封装信息" -- **实际**: ✅ 捕获StructureError: "A1 单元格为空，缺少封装信息" -- **结果**: **通过** +### TC-MAP-006: A1为空检测 +- **结果**: ✅ 通过 +- **详情**: 正确报错: A1 单元格为空，缺少封装信息 ---- +## Part 2: List→MAP 新增功能测试 -## 端到端测试 +### TC-LM-001: 5×5 PinList→PinMAP (16引脚) +- **结果**: ✅ 通过 +- **详情**: 解析成功, 封装=QFP-16, Pin数=16, 5×5布局验证通过 -### main.py 命令行模式 -```bash -python main.py /tmp/test_4x4.xlsx -``` -**输出**: -``` -[INFO] 解析完成: 6x6 方形，共 8 个Pin -[INFO] 封装信息: QFP44 +### TC-LM-002: 6×12 PinList→PinMAP (32引脚) +- **结果**: ✅ 通过 +- **详情**: 解析成功, 封装=LQFP-32, Pin数=32, 6×12布局+文件输出验证通过 -[SUCCESS] 转换完成！输出文件: /tmp/test_4x4_PinList.xlsx - - 封装信息: QFP44 - - Pin数量: 8 -``` -**结果**: ✅ 通过 +### TC-LM-003: 带模板文件的转换 +- **结果**: ✅ 通过 +- **详情**: 模板样式读取成功, 带模板输出文件包含styles.xml -### 输出文件验证 -- **输入**: `sample_4x4.xlsx` → **输出**: `sample_4x4_PinList.xlsx` -- **A1**: QFP44 ✅ -- **A列**: Pin1, Pin2, Pin3, Pin4, Pin5, Pin6, Pin7, Pin8 ✅ -- **B列**: 1, 2, 3, 4, 5, 6, 7, 8 ✅ -- **排序**: 递增 ✅ +### TC-LM-004: Pin序号不连续 +- **结果**: ✅ 通过 +- **详情**: 正确报错: Pin序号不连续 — 缺失的序号: [3] ---- +### TC-LM-005: Pin序号重复 +- **结果**: ✅ 通过 +- **详情**: 正确报错: Pin序号不连续 — 缺失的序号: [4] -## 模块单元测试 +### TC-LM-006: Pin总数不匹配 +- **结果**: ✅ 通过 +- **详情**: 正确报错: Pin数量与网格周长不匹配 — 网格 3×4 需要 10 个引脚，但 PinList 有 8 个 -### xlsx_roundtrip -- 写入 → 读取 → 验证数据一致 ✅ +### TC-LM-007: 缺少PinName (warning) +- **结果**: ✅ 通过 +- **详情**: 验证通过(有warning): 检测到 1 个引脚缺少 PinName — 缺失引脚序号: [2]，将默认为 NC -### pinmap_parser -- 4x4方形解析 ✅ -- 长方形解析 ✅ -- 角点去重 ✅ +### TC-LM-008: 非4倍数提示 +- **结果**: ✅ 通过 +- **详情**: 验证通过, Pin数=6 (非4倍数) -### validator -- 连续性检查 ✅ -- 唯一性检查 ✅ -- PinName缺失检测 ✅ -- 结构完整性检查 ✅ +### TC-LM-009: 布局计算正确性 +- **结果**: ✅ 通过 +- **详情**: 布局计算正确: left=3, bottom=2, right=1, top=2, 逆时针顺序正确 -### pinlist_generator -- PinList生成 ✅ -- NC默认值 ✅ -- 递增排序 ✅ +### TC-LM-010: 模板文件检测(无模板) +- **结果**: ✅ 通过 +- **详情**: 无模板文件时优雅返回None ---- +### TC-LM-011: 无效尺寸输入(行数<2) +- **结果**: ✅ 通过 +- **详情**: 正确报错: 行数无效: 1，至少需要 2 行 -## 问题汇总 +### TC-LM-011b: 无效尺寸输入(列数<2) +- **结果**: ✅ 通过 +- **详情**: 正确报错: 列数无效: 1，至少需要 2 列 -| 问题 | 严重性 | 状态 | -|------|--------|------| -| 无 | - | - | +### TC-LM-012: 输出文件正确性 +- **结果**: ✅ 通过 +- **详情**: 输出文件验证通过: A1=QFP-8, 包含Pin1-Pin8 -**所有测试用例通过，无阻塞性问题。** +### TC-LM-013: 端到端Roundtrip (MAP→List→MAP) +- **结果**: ✅ 通过 +- **详情**: Roundtrip成功: PinList(8) → PinMAP(3×3) → PinList(8), 序号一致 ---- +### TC-LM-014: 输出路径生成 +- **结果**: ✅ 通过 +- **详情**: 路径生成正确: /path/to/my_pinlist_PinMAP.xlsx -## 改进建议 +### TC-LM-015: 空PinList文件 +- **结果**: ✅ 通过 +- **详情**: 正确报错: 未找到任何引脚数据（A/B 列为空） -1. **XLS读取测试**: 当前环境无.xls测试样本，建议在Windows环境用真实.xls文件验证BIFF8解析 -2. **字体格式保留**: 当前版本未实现字体格式保留（架构设计中有提及），可在后续版本添加 -3. **GUI模式**: tkinter文件选择对话框在Linux无头环境下需回退到命令行参数，已实现 -4. **性能优化**: 当前实现适合<1000引脚场景，超大文件可后续优化 +### TC-LM-016: A1为空的PinList +- **结果**: ✅ 通过 +- **详情**: 正确报错: A1 单元格为空，无法获取封装信息 --- @@ -129,21 +118,6 @@ python main.py /tmp/test_4x4.xlsx ✅ **所有测试用例通过，项目可进入发布阶段。** -**交付物清单**: -- `Code/src/main.py` — 主入口 -- `Code/src/file_selector.py` — 文件选择 -- `Code/src/xls_reader.py` — XLS读取引擎 (19KB) -- `Code/src/xlsx_reader.py` — XLSX读取引擎 -- `Code/src/xlsx_writer.py` — XLSX写入引擎 -- `Code/src/pinmap_parser.py` — PinMAP解析器 -- `Code/src/validator.py` — 数据验证器 -- `Code/src/pinlist_generator.py` — PinList生成器 -- `Code/src/models.py` — 数据模型 -- `Code/src/utils.py` — 工具函数 -- `Code/docs/architecture-design.md` — 架构设计文档 -- `Test/fixtures/` — 测试夹具 (6个文件) -- `Test/test_report.md` — 测试报告 - --- -*测试完成 — 2026-05-25* +*测试完成* \ No newline at end of file