v0.11.2

fix pack install 2

fix pip install & git install failed

fix pack build 1

Update SKILL.md

Update Skills

Update registry for all param desc

.conda/base/recipe.yaml

@@ -3,7 +3,7 @@
 
 package:
   name: unilabos
-  version: 0.11.1
+  version: 0.11.2
 
 source:
   path: ../../unilabos
@@ -54,7 +54,7 @@ requirements:
   - pymodbus
   - matplotlib
   - pylibftdi
-  - uni-lab::unilabos-env ==0.11.1
+  - uni-lab::unilabos-env ==0.11.2
 
 about:
   repository: https://github.com/deepmodeling/Uni-Lab-OS

.conda/environment/recipe.yaml

@@ -2,7 +2,7 @@
 
 package:
   name: unilabos-env
-  version: 0.11.1
+  version: 0.11.2
 
 build:
   noarch: generic

.conda/full/recipe.yaml

@@ -3,7 +3,7 @@
 
 package:
   name: unilabos-full
-  version: 0.11.1
+  version: 0.11.2
 
 build:
   noarch: generic
@@ -11,7 +11,7 @@ build:
 requirements:
   run:
   # Base unilabos package (includes unilabos-env)
-  - uni-lab::unilabos ==0.11.1
+  - uni-lab::unilabos ==0.11.2
   # Documentation tools
   - sphinx
   - sphinx_rtd_theme

plan/2026-05-20_add_two_node.md

@@ -1,576 +0,0 @@
-# Peptide Station 新增三个节点：等待订单完成 + 下料确认 + take-out 同步
-
-> 日期: 2026-05-20  
-> 目标文件: [peptide_station.py](../unilabos/devices/workstation/bioyond_studio/peptide_station/peptide_station.py)  
-> 参考实现:  
-> - [bioyond_cell_workstation.py](/Users/dp/python/yxz/unilabos/devices/workstation/bioyond_studio/bioyond_cell/bioyond_cell_workstation.py)（`wait_for_order_finish`、`get_material_info`）
-> - [bioyond_rpc.py L782-824](../unilabos/devices/workstation/bioyond_studio/bioyond_rpc.py)（`take_out`）
-> - [workstation_architecture.md](../docs/developer_guide/examples/workstation_architecture.md)（HTTP 报送进入 workstation，运行态记录保存在 workstation 内存）
-> 状态: 仅需求草稿，不写代码
-
----
-
-## 一、需求背景
-
-`BioyondPeptideStation` 当前实验流程在 `start_experiment`（manual_confirm 启动调度器）之后即结束，缺少：
-
-1. **等待奔耀回报实验完成**：调度器跑完后，奔耀通过 LIMS 推送 `POST /report/order_finish` 回调；目前 peptide_station 没有把这条推送封装成 action 节点，下游无法在工作流图上等待结果，也拿不到 `usedMaterials` 等下游所需信息。
-2. **下料引导**：实验完成后操作员需要把样品/产物从仓位里取出，下料前需要看到每个物料对应的 **仓库 / 位置 / 物料名称 / 数量**；下料完成后还需要回写奔耀（调用 `take-out` 接口），让奔耀清空相应库位状态。
-
-本轮新增三个 action 节点，串在 `start_experiment` 之后：
-
-```text
-submit_experiment_dayN
-  -> start_experiment(manual_confirm 上料)
-  -> wait_for_order_finish (等回调 + 生成 unloadTable)
-  -> confirm_unload_materials (manual_confirm 下料确认)
-  -> take_out_materials (调用 take-out 同步奔耀)
-```
-
----
-
-## 二、关键设计决策
-
-### D1. 本轮只支持单订单，`order_ids` 只做占位
-
-当前不实现多订单等待、乱序回调缓存、并发 wait 隔离。节点输入以 `order_id` 为主，`order_code` 可作为调试兜底。
-
-`order_ids` 可在 handle/返回值中保留为占位字段，但实现只处理第一笔或直接忽略多订单列表。多订单、乱序回调、跨节点重跑复用缓存放到后续迭代。
-
-### D2. `start_experiment` 需要显式透传订单字段
-
-当前 `start_experiment` 只有输入 handles，缺少输出 handles；如果下游 wait 节点要接在 `start_experiment` 之后，必须让 `start_experiment` 透传：
-
-- `order_id`
-- `order_ids`（占位）
-- `order_code`
-- `resultTable`
-
-实现时给 `start_experiment` 增加对应 `ActionOutputHandle`，并在返回值里保留这些字段。`submit_experiment_dayN` 的 `start_experiment` 嵌套字典也应包含 `order_code`，便于工作流编辑器连线。
-
-### D3. `unloadTable` 必须与 `resultTable` 字段一致
-
-`unloadTable` 不新增 `posX/posY/posZ/unit` 列，直接复用现有 `RESULT_TABLE_COLUMNS` 的四列：
-
-```python
-RESULT_TABLE_COLUMNS = [
-    {"name": "设备", "key": "whName"},
-    {"name": "位置", "key": "locationCode"},
-    {"name": "物料名称", "key": "materialName"},
-    {"name": "数量", "key": "quantity"},
-]
-```
-
-`submit_experiment_dayN` 现有上料确认表 `resultTable` 形状如下；`unloadTable` 也必须保持同一 shape，只改 `tableName` 和行数据来源：
-
-```json
-{
-  "data": [
-    {
-      "whName": "自动化堆栈",
-      "locationCode": "A1",
-      "materialName": "96孔板",
-      "quantity": "1"
-    }
-  ],
-  "columns": [
-    {"name": "设备", "key": "whName"},
-    {"name": "位置", "key": "locationCode"},
-    {"name": "物料名称", "key": "materialName"},
-    {"name": "数量", "key": "quantity"}
-  ],
-  "tableName": "resultTable"
-}
-```
-
-`material-info` 官方 schema 中位置坐标字段是 `locations[].x/y/z`，不是 `posX/posY/posZ`。本轮下料表不展示坐标。
-
-### D4. manual_confirm 只做人确认，take-out 放到普通 action
-
-`confirm_unload_materials` 只负责展示下料表、等待操作员确认并透传数据；真正的 `take-out` 调用放到后续普通 action `take_out_materials`。
-
-这样更接近 UniLab manual_confirm 的推荐模式：manual_confirm 是人机确认检查点，副作用由独立普通 action 执行。
-
-### D5. 本轮不做 unload context 缓存
-
-虽然 workstation architecture 文档支持在 workstation 内存保存 HTTP 报送记录，但本轮暂不实现 `unload_context_cache` 或 order report 缓存。
-
-因此本轮限制如下：
-
-- `wait_for_order_finish` 只等待本次进入节点之后到达的 `/report/order_finish`。
-- 如果 push 早于 wait 节点到达，本轮不自动补救。
-- 如果用户在 `confirm_unload_materials` approve 时忘记勾选，节点失败；当前架构不支持原地重新弹出同一个 manual_confirm，也不在本轮实现失败节点重跑。
-- 后续若要支持重跑复用，应在 `BioyondPeptideStation` 实例上新增 station runtime 的 `unload_context_cache`，按 `orderCode` 缓存 `unloadTable/material_ids/order_id` 等上下文。
-
----
-
-## 三、节点 1：`wait_for_order_finish`（等推送 + 生成 unloadTable）
-
-### 行为
-
-1. 解析单订单目标：
-   - 首选 `order_id`。
-   - 如果没有 `order_code`，通过 `self.hardware_interface.order_report(order_id)` 取返回数据中的 `code` 作为 `orderCode`。
-   - `order_ids` 仅占位，本轮不实现多订单循环。
-2. 设置 `self.last_order_code = order_code`、`self.last_order_report = None`，并 `self.order_finish_event.clear()`。
-3. 阻塞在 `self.order_finish_event.wait(timeout=timeout_seconds)` 等 LIMS 推送。
-4. peptide_station override `process_order_finish_report(report_request, used_materials)`：
-   - 先调用 `super().process_order_finish_report(...)` 保留父类行为（状态发布、物料同步等）。
-   - 当 `report_request.data.orderCode == self.last_order_code` 时，把 `report_request.data` 存入 `self.last_order_report`，并 `set()` event。
-   - 非当前订单推送只记录日志，本轮不缓存。
-5. 解除阻塞后解析 `status`：
-   - `"30"` -> `success`
-   - `"-11"` -> `abnormal_stop`
-   - `"-12"` -> `manual_stop`
-   - 其它 -> `unknown_<status>`
-   - 超时 -> `timeout`
-6. 对 `report.usedMaterials[].materialId` 调用 `self.hardware_interface.material_info(material_id)`，带本地函数级 `material_info_cache` 避免重复请求。
-7. 组装 `unloadTable`、`material_ids`、`preintake_ids`、`unload_summary` 并作为输出 handles 暴露。
-
-### 入参（goal_default）
-
-| 参数 | 类型 | 说明 |
-|------|------|------|
-| `order_id` | `str` | 来自 `start_experiment` 透传输出，必填优先 |
-| `order_code` | `str` | 调试兜底；若已知 orderCode 可跳过 `order_report` 反查 |
-| `order_ids` | `List[str]` | 占位字段；本轮不实现多订单 |
-| `timeout_seconds` | `int` | 默认 `36000`（10h） |
-| `poll_mode` | `bool` | 默认 `False`；如需要可沿用 bioyond_cell 的轮询等待风格 |
-
-### 输出 handles
-
-| key | data_type | 说明 |
-|-----|-----------|------|
-| `order_finish_status` | `str` | `success` / `abnormal_stop` / `manual_stop` / `timeout` / `unknown_*` |
-| `order_finish_report` | `json` | 完整 `report_request.data` |
-| `used_materials` | `json` | JSON 化后的 `usedMaterials` 列表 |
-| `material_ids` | `json` | 从 `used_materials` 抽出的 `materialId` 列表，可为空 |
-| `preintake_ids` | `json` | 本轮默认 `[]`，保留扩展点 |
-| `unloadTable` | `table` | 下料表，字段与 `resultTable` 一致 |
-| `unload_summary` | `json` | `{ "order_code": ..., "total_items": N, "missing_material_info": [...] }` |
-| `order_id` | `str` | 透传给后续节点 |
-| `order_code` | `str` | 透传给后续节点 |
-| `order_ids` | `json` | 占位透传 |
-
-### `unloadTable` 组装规则
-
-返回结构：
-
-```json
-{
-  "data": [
-    {
-      "whName": "自动化堆栈",
-      "locationCode": "A1",
-      "materialName": "多肽产物",
-      "quantity": "10 mg"
-    }
-  ],
-  "columns": [
-    {"name": "设备", "key": "whName"},
-    {"name": "位置", "key": "locationCode"},
-    {"name": "物料名称", "key": "materialName"},
-    {"name": "数量", "key": "quantity"}
-  ],
-  "tableName": "unloadTable"
-}
-```
-
-每行字段：
-
-| key | 数据来源 |
-|-----|----------|
-| `whName` | `material_info.locations` 中匹配 `usedMaterials.locationId` 的 location 的 `whName`；匹配不到取第一条 location 的 `whName`；失败为空串 |
-| `locationCode` | 匹配 location 的 `code`；匹配不到取第一条 location 的 `code`；再兜底 `usedMaterials.locationId` |
-| `materialName` | `material_info.name`；失败为空串 |
-| `quantity` | `usedMaterials.usedQuantity`，若 `material_info.unit` 存在则拼成字符串（如 `"10 mg"`） |
-
-`material-info` 失败时不抛异常，对应行尽量保留 `locationCode` / `quantity`，`whName` 和 `materialName` 用空串，并把 `materialId` 放入 `unload_summary.missing_material_info`。
-
-### 接口依赖
-
-| 接口 | 调用方式 | 用途 |
-|------|----------|------|
-| `process_order_finish_report` 钩子 | 基类 HTTP 服务已注册 | 接 LIMS push |
-| `POST /api/lims/order/order-report` | `self.hardware_interface.order_report(order_id)` | 从 `order_id` 反查 `orderCode` |
-| `POST /api/lims/storage/material-info` | `self.hardware_interface.material_info(material_id)` | 查 `whName/locationCode/materialName/unit` |
-
-#### `order_report(order_id)` API 形式
-
-请求：
-
-```json
-{
-  "apiKey": "B10B5995",
-  "requestTime": "2026-05-20T10:50:00.123Z",
-  "data": "<orderId UUID>"
-}
-```
-
-响应中本节点只依赖 `data.code`：
-
-```json
-{
-  "code": 1,
-  "message": null,
-  "timestamp": 1779255000000,
-  "data": {
-    "id": "<orderId UUID>",
-    "name": "实验260520-103000",
-    "code": "EXP260520-103000",
-    "status": 30,
-    "statusName": "完成"
-  }
-}
-```
-
-`BioyondV1RPC.order_report(order_id)` 已经返回响应中的 `data`，所以实现中应读取 `raw.get("code")`，不是 `raw["data"]["code"]`。
-
-#### `material_info(material_id)` API 形式
-
-请求：
-
-```json
-{
-  "apiKey": "B10B5995",
-  "requestTime": "2026-05-20T10:50:00.123Z",
-  "data": "<materialId UUID>"
-}
-```
-
-响应中本节点依赖：
-
-```json
-{
-  "id": "<materialId UUID>",
-  "name": "多肽产物",
-  "unit": "mg",
-  "locations": [
-    {
-      "id": "<locationId UUID>",
-      "whid": "<warehouse UUID>",
-      "whName": "自动化堆栈",
-      "code": "A1",
-      "x": 1,
-      "y": 1,
-      "z": 1,
-      "quantity": 10
-    }
-  ]
-}
-```
-
-`BioyondV1RPC.material_info(material_id)` 已经返回响应中的 `data`。字段映射：
-
-| unloadTable key | 来源 |
-|-----------------|------|
-| `whName` | 匹配 `locationId` 的 `locations[].whName` |
-| `locationCode` | 匹配 `locationId` 的 `locations[].code` |
-| `materialName` | `name` |
-| `quantity` | `usedMaterials[].usedQuantity` + `unit` |
-
-### 实现要点
-
-- `BioyondPeptideStation.__init__` 末尾追加 `self.order_finish_event = threading.Event()`、`self.last_order_code = None`、`self.last_order_report = None`。
-- 新增 `process_order_finish_report` override，先 `super()`，再做单订单匹配。
-- `used_materials` 参数是 `MaterialUsage` dataclass 列表；输出前必须转成 JSON dict。
-- `unloadTable` 复用 `RESULT_TABLE_COLUMNS`，不新增 `UNLOAD_TABLE_COLUMNS`。
-
----
-
-## 四、节点 2：`confirm_unload_materials`（人工下料确认）
-
-### 行为
-
-1. 接收节点 1 输出的 `order_id` / `order_code` / `material_ids` / `preintake_ids` / `unloadTable`。
-2. 进入 `NodeType.MANUAL_CONFIRM` 阻塞，操作员根据 `unloadTable` 物理下料。
-3. 操作员勾选 `materials_unloaded=True` 并 approve 后，节点函数体继续。
-4. 校验 `materials_unloaded == True`：
-   - 为 True：返回确认结果，并透传 `order_id/material_ids/preintake_ids/unloadTable` 给节点 3。
-   - 为 False：抛 `RuntimeError("下料未确认，拒绝继续 take-out")`。
-
-### 入参（goal_default）
-
-| 参数 | 类型 | 说明 |
-|------|------|------|
-| `order_id` | `str` | 来自节点 1，必填 |
-| `order_code` | `str` | 来自节点 1，日志/排错用 |
-| `material_ids` | `List[str]` | 来自节点 1，可为空 |
-| `preintake_ids` | `List[str]` | 来自节点 1，默认 `[]` |
-| `unloadTable` | `table` | 来自节点 1，供人工确认展示 |
-| `materials_unloaded` | `bool` | manual_confirm 勾选字段，默认 `False` |
-| `timeout_seconds` | `int` | 默认 `3600` |
-| `assignee_user_ids` | `List[str]` | `placeholder_keys={"assignee_user_ids": "unilabos_manual_confirm"}` |
-
-### 输出 handles
-
-| key | data_type | 说明 |
-|-----|-----------|------|
-| `unload_confirmed` | `bool` | 是否已人工确认下料 |
-| `order_id` | `str` | 透传 |
-| `order_code` | `str` | 透传 |
-| `material_ids` | `json` | 透传 |
-| `preintake_ids` | `json` | 透传 |
-| `unloadTable` | `table` | 透传 |
-
-### 实现要点
-
-- 装饰器使用 `node_type=NodeType.MANUAL_CONFIRM`。
-- `always_free=True`、`placeholder_keys`、`feedback_interval=300` 与现有 `start_experiment` 保持一致。
-- 本节点不调用 `take_out`，只做确认与透传。
-- 忘记勾选后不会自动重新显示下料指引；本轮不实现缓存或失败节点原地重跑。
-
----
-
-## 五、节点 3：`take_out_materials`（调用 take-out 同步奔耀）
-
-### 行为
-
-1. 接收节点 2 透传的 `order_id` / `material_ids` / `preintake_ids`。
-2. 校验 `order_id` 非空。
-3. 调用 `self.hardware_interface.take_out(order_id, preintake_ids=preintake_ids, material_ids=material_ids)`。
-4. 返回 `take_out_result`、`unloaded_count`、`success`。
-
-### 入参
-
-| 参数 | 类型 | 说明 |
-|------|------|------|
-| `order_id` | `str` | 必填 |
-| `material_ids` | `List[str]` | 可为空；为空时由奔耀按 `orderId` 处理的能力以后现场确认 |
-| `preintake_ids` | `List[str]` | 可为空，默认 `[]` |
-| `order_code` | `str` | 日志/排错用 |
-
-### 输出 handles
-
-| key | data_type | 说明 |
-|-----|-----------|------|
-| `take_out_result` | `json` | `take-out` 原始响应 `{code, message, timestamp, data}` |
-| `unloaded_count` | `int` | `len(material_ids)` |
-| `success` | `bool` | `take_out_result.code == 1` 且 `data` 不为 False |
-
-### 接口依赖
-
-| 接口 | 调用方式 | 用途 |
-|------|----------|------|
-| `POST /api/lims/order/take-out` | `self.hardware_interface.take_out(order_id, preintake_ids, material_ids)` | 通知奔耀同步取出 |
-
-请求体 schema（helper script 已核对）：
-
-```json
-{
-  "apiKey": "B10B5995",
-  "requestTime": "2026-05-20T10:50:00.123Z",
-  "data": {
-    "orderId": "<UUID>",
-    "preintakeIds": [],
-    "materialIds": ["<UUID-1>", "<UUID-2>"]
-  }
-}
-```
-
-响应 schema：
-
-```json
-{
-  "code": 1,
-  "message": null,
-  "timestamp": 1779255000000,
-  "data": true
-}
-```
-
-`BioyondV1RPC.take_out(...)` 返回完整响应包，因此 `take_out_materials` 应保留原始包到 `take_out_result`。
-
-### 实现要点
-
-- 本轮不修改 `sample_waste_removal`，保持 backward compatibility。
-- 新节点只调用现有完整能力的 `take_out(...)`。
-- `preintake_ids` / `material_ids` 都按可选列表处理，默认 `[]`。
-- `take-out` 返回 `code != 1` 时返回 `success=False` 并记录 warning；是否抛异常留作开放问题。
-
----
-
-## 六、端到端工作流连线
-
-```mermaid
-flowchart LR
-    submit["submit_experiment_dayN"] --> start["start_experiment<br/>manual_confirm: 上料"]
-    start -->|order_id, order_code| wait["wait_for_order_finish<br/>等 order_finish + 生成 unloadTable"]
-    wait -->|order_id, material_ids,<br/>preintake_ids, unloadTable| confirm["confirm_unload_materials<br/>manual_confirm: 操作员下料确认"]
-    confirm -->|order_id, material_ids,<br/>preintake_ids| takeout["take_out_materials<br/>调用 take-out 同步奔耀"]
-    bioyond["奔耀 LIMS"] -.HTTP POST /report/order_finish.-> wait
-    wait -.material-info.-> bioyond
-    takeout -.take-out.-> bioyond
-```
-
----
-
-## 七、影响面与兼容性
-
-- **`peptide_station.py`**
-  - 修改 `start_experiment`：增加 `order_id/order_code/order_ids/resultTable` 输出 handles，并在返回值透传。
-  - 增加 `wait_for_order_finish`、`confirm_unload_materials`、`take_out_materials` 三个 action。
-  - 增加 `process_order_finish_report` override。
-  - 增加 `_build_unload_table(...)` 等私有辅助方法。
-- **`bioyond_rpc.py` 不动**
-  - `take_out` 已有完整 schema 能力。
-  - `sample_waste_removal` 本轮不改，保持兼容。
-- **基类 `station.py` 不动**
-  - override 中保留 `super().process_order_finish_report(...)` 调用。
-- **HTTP 服务不动**
-  - `WorkstationHTTPService` 已支持 `/report/order_finish`。
-- **本轮不做缓存**
-  - 不新增 `unload_context_cache`。
-  - 不支持 push 早于 wait 的自动补救。
-  - 不支持失败 manual_confirm 原地重跑。
-- **测试**：补在现有路径 `unilabos/devices/workstation/bioyond_studio/peptide_station/tests/test_peptide_station_contracts.py`
-  1. `start_experiment` 输出 handles/返回值透传 `order_id/order_code/order_ids/resultTable`。
-  2. `process_order_finish_report` orderCode 匹配 / 不匹配时 event 是否触发。
-  3. `wait_for_order_finish` 单订单成功、超时、状态映射、`used_materials` JSON 化。
-  4. `_build_unload_table` 列顺序严格等于 `RESULT_TABLE_COLUMNS`，且无 `posX/posY/posZ/unit` 列。
-  5. `material-info` 失败时不抛异常，`missing_material_info` 正确记录。
-  6. `confirm_unload_materials` 未勾选时报错，勾选后透传下游字段且不调用 `take_out`。
-  7. `take_out_materials` 调用 `hardware_interface.take_out(order_id, preintake_ids, material_ids)`，不调用 `sample_waste_removal`。
-
----
-
-## 八、待人类确认的开放问题
-
-1. **过滤产物 vs 全量**：`usedMaterials` 同时包含试剂、耗材、样品（`typeMode` 区分），下料表是否需要默认排除试剂/耗材？当前默认全量列出。
-2. **take-out 失败是否阻塞工作流**：本计划暂定返回 `success=False` 并 warning，不抛异常；如果希望奔耀仓位状态必须一致，可改为抛 `RuntimeError`。
-3. **后续缓存/重跑能力**：如果要支持 push 早到、忘勾选后重跑复用 `unloadTable`，后续应在 `BioyondPeptideStation` station runtime 上实现 `unload_context_cache`，但本轮不做。
-4. **多订单**：本轮只保留 `order_ids` 占位，不实现多订单等待、乱序回调或并发 wait。
-
----
-
-## 附录 A：API schema 核对摘要
-
-使用 `temp_benyao/scripts/api_helper.py --root temp_benyao/peptide` 核对：
-
-### A.1 `POST /api/lims/storage/material-info`
-
-请求：
-
-```json
-{
-  "apiKey": "B10B5995",
-  "requestTime": "2026-05-20T10:50:00.123Z",
-  "data": "<materialId UUID>"
-}
-```
-
-响应关键字段：
-
-```json
-{
-  "id": "<materialId UUID>",
-  "typeName": "样品",
-  "code": "MAT-001",
-  "barCode": "BC-001",
-  "name": "多肽产物",
-  "quantity": 10,
-  "lockQuantity": 0,
-  "unit": "mg",
-  "status": 1,
-  "isUse": true,
-  "locations": [
-    {
-      "id": "<locationId UUID>",
-      "whid": "<warehouse UUID>",
-      "whName": "自动化堆栈",
-      "code": "A1",
-      "x": 1,
-      "y": 1,
-      "z": 1,
-      "quantity": 10
-    }
-  ],
-  "detail": []
-}
-```
-
-注意：schema 没有 `posX/posY/posZ`，本轮也不展示坐标。
-
-### A.2 `POST /api/lims/order/take-out`
-
-请求：
-
-```json
-{
-  "apiKey": "B10B5995",
-  "requestTime": "2026-05-20T10:50:00.123Z",
-  "data": {
-    "orderId": "<orderId UUID>",
-    "preintakeIds": [],
-    "materialIds": ["<materialId UUID>"]
-  }
-}
-```
-
-响应：
-
-```json
-{
-  "code": 1,
-  "message": null,
-  "timestamp": 1779255000000,
-  "data": true
-}
-```
-
-源码中已有 `BioyondV1RPC.take_out(order_id, preintake_ids=None, material_ids=None)`，本轮复用它。
-
-### A.3 `/report/order_finish`
-
-`/report/order_finish` 不在 Peptide JSON OpenAPI specs 中；schema 依据：
-
-- `unilabos/devices/workstation/workstation_http_service.py`
-- `temp_benyao/peptide/docs/reference/api_manual.md`
-
-关键字段：
-
-```json
-{
-  "token": "token-from-lims",
-  "request_time": "2026-05-20 10:50:00.123",
-  "data": {
-    "orderCode": "EXP260520-103000",
-    "orderName": "实验260520-103000",
-    "startTime": "2026-05-20 09:00:00",
-    "endTime": "2026-05-20 10:50:00",
-    "status": "30",
-    "usedMaterials": [
-      {
-        "materialId": "<materialId UUID>",
-        "locationId": "<locationId UUID>",
-        "typeMode": "1",
-        "usedQuantity": 10
-      }
-    ]
-  }
-}
-```
-
-`WorkstationHTTPService` 会把 `usedMaterials[]` 转成 `MaterialUsage` dataclass 列表传给 `process_order_finish_report(report_request, used_materials)`；peptide 输出 `used_materials` handle 前需要转回 JSON dict：
-
-```json
-[
-  {
-    "materialId": "<materialId UUID>",
-    "locationId": "<locationId UUID>",
-    "typeMode": "1",
-    "usedQuantity": 10
-  }
-]
-```
-
----
-
-## 附录 B：本轮不实现的内容
-
-- 不做 station runtime 的 `unload_context_cache`。
-- 不做多订单。
-- 不做 push 早到后的补救。
-- 不做 failed manual_confirm 原地重跑。
-- 不改前端。
-- 不改 `sample_waste_removal`。

recipes/msgs/recipe.yaml

@@ -1,6 +1,6 @@
 package:
   name: ros-humble-unilabos-msgs
-  version: 0.11.1
+  version: 0.11.2
 source:
   path: ../../unilabos_msgs
   target_directory: src

recipes/unilabos/recipe.yaml

@@ -1,6 +1,6 @@
 package:
   name: unilabos
-  version: "0.11.1"
+  version: "0.11.2"
 
 source:
   path: ../..

scripts/workflow.py

@@ -2,6 +2,7 @@ import json
 import logging
 import traceback
 import uuid
+import xml.etree.ElementTree as ET
 from typing import Any, Dict, List
 
 import networkx as nx
@@ -24,15 +25,7 @@ class SimpleGraph:
 
     def add_edge(self, source, target, **attrs):
         """添加边"""
-        # edge = {"source": source, "target": target, **attrs}
-        edge = {
-            "source": source, "target": target,
-            "source_node_uuid": source,
-            "target_node_uuid": target,
-            "source_handle_io": "source",
-            "target_handle_io": "target",
-            **attrs
-        }
+        edge = {"source": source, "target": target, **attrs}
         self.edges.append(edge)
 
     def to_dict(self):
@@ -49,7 +42,6 @@ class SimpleGraph:
             "multigraph": False,
             "graph": {},
             "nodes": nodes_list,
-            "edges": self.edges,
             "links": self.edges,
         }
 
@@ -66,8 +58,495 @@ def extract_json_from_markdown(text: str) -> str:
     return text
 
 
+def convert_to_type(val: str) -> Any:
+    """将字符串值转换为适当的数据类型"""
+    if val == "True":
+        return True
+    if val == "False":
+        return False
+    if val == "?":
+        return None
+    if val.endswith(" g"):
+        return float(val.split(" ")[0])
+    if val.endswith("mg"):
+        return float(val.split("mg")[0])
+    elif val.endswith("mmol"):
+        return float(val.split("mmol")[0]) / 1000
+    elif val.endswith("mol"):
+        return float(val.split("mol")[0])
+    elif val.endswith("ml"):
+        return float(val.split("ml")[0])
+    elif val.endswith("RPM"):
+        return float(val.split("RPM")[0])
+    elif val.endswith(" °C"):
+        return float(val.split(" ")[0])
+    elif val.endswith(" %"):
+        return float(val.split(" ")[0])
+    return val
 
 
+def refactor_data(data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """统一的数据重构函数，根据操作类型自动选择模板"""
+    refactored_data = []
+
+    # 定义操作映射，包含生物实验和有机化学的所有操作
+    OPERATION_MAPPING = {
+        # 生物实验操作
+        "transfer_liquid": "SynBioFactory-liquid_handler.prcxi-transfer_liquid",
+        "transfer": "SynBioFactory-liquid_handler.biomek-transfer",
+        "incubation": "SynBioFactory-liquid_handler.biomek-incubation",
+        "move_labware": "SynBioFactory-liquid_handler.biomek-move_labware",
+        "oscillation": "SynBioFactory-liquid_handler.biomek-oscillation",
+        # 有机化学操作
+        "HeatChillToTemp": "SynBioFactory-workstation-HeatChillProtocol",
+        "StopHeatChill": "SynBioFactory-workstation-HeatChillStopProtocol",
+        "StartHeatChill": "SynBioFactory-workstation-HeatChillStartProtocol",
+        "HeatChill": "SynBioFactory-workstation-HeatChillProtocol",
+        "Dissolve": "SynBioFactory-workstation-DissolveProtocol",
+        "Transfer": "SynBioFactory-workstation-TransferProtocol",
+        "Evaporate": "SynBioFactory-workstation-EvaporateProtocol",
+        "Recrystallize": "SynBioFactory-workstation-RecrystallizeProtocol",
+        "Filter": "SynBioFactory-workstation-FilterProtocol",
+        "Dry": "SynBioFactory-workstation-DryProtocol",
+        "Add": "SynBioFactory-workstation-AddProtocol",
+    }
+
+    UNSUPPORTED_OPERATIONS = ["Purge", "Wait", "Stir", "ResetHandling"]
+
+    for step in data:
+        operation = step.get("action")
+        if not operation or operation in UNSUPPORTED_OPERATIONS:
+            continue
+
+        # 处理重复操作
+        if operation == "Repeat":
+            times = step.get("times", step.get("parameters", {}).get("times", 1))
+            sub_steps = step.get("steps", step.get("parameters", {}).get("steps", []))
+            for i in range(int(times)):
+                sub_data = refactor_data(sub_steps)
+                refactored_data.extend(sub_data)
+            continue
+
+        # 获取模板名称
+        template = OPERATION_MAPPING.get(operation)
+        if not template:
+            # 自动推断模板类型
+            if operation.lower() in ["transfer", "incubation", "move_labware", "oscillation"]:
+                template = f"SynBioFactory-liquid_handler.biomek-{operation}"
+            else:
+                template = f"SynBioFactory-workstation-{operation}Protocol"
+
+        # 创建步骤数据
+        step_data = {
+            "template": template,
+            "description": step.get("description", step.get("purpose", f"{operation} operation")),
+            "lab_node_type": "Device",
+            "parameters": step.get("parameters", step.get("action_args", {})),
+        }
+        refactored_data.append(step_data)
+
+    return refactored_data
+
+
+def build_protocol_graph(
+    labware_info: List[Dict[str, Any]], protocol_steps: List[Dict[str, Any]], workstation_name: str
+) -> SimpleGraph:
+    """统一的协议图构建函数，根据设备类型自动选择构建逻辑"""
+    G = SimpleGraph()
+    resource_last_writer = {}
+    LAB_NAME = "SynBioFactory"
+
+    protocol_steps = refactor_data(protocol_steps)
+
+    # 检查协议步骤中的模板来判断协议类型
+    has_biomek_template = any(
+        ("biomek" in step.get("template", "")) or ("prcxi" in step.get("template", ""))
+        for step in protocol_steps
+    )
+
+    if has_biomek_template:
+        # 生物实验协议图构建
+        for labware_id, labware in labware_info.items():
+            node_id = str(uuid.uuid4())
+
+            labware_attrs = labware.copy()
+            labware_id = labware_attrs.pop("id", labware_attrs.get("name", f"labware_{uuid.uuid4()}"))
+            labware_attrs["description"] = labware_id
+            labware_attrs["lab_node_type"] = (
+                "Reagent" if "Plate" in str(labware_id) else "Labware" if "Rack" in str(labware_id) else "Sample"
+            )
+            labware_attrs["device_id"] = workstation_name
+
+            G.add_node(node_id, template=f"{LAB_NAME}-host_node-create_resource", **labware_attrs)
+            resource_last_writer[labware_id] = f"{node_id}:labware"
+
+        # 处理协议步骤
+        prev_node = None
+        for i, step in enumerate(protocol_steps):
+            node_id = str(uuid.uuid4())
+            G.add_node(node_id, **step)
+
+            # 添加控制流边
+            if prev_node is not None:
+                G.add_edge(prev_node, node_id, source_port="ready", target_port="ready")
+            prev_node = node_id
+
+            # 处理物料流
+            params = step.get("parameters", {})
+            if "sources" in params and params["sources"] in resource_last_writer:
+                source_node, source_port = resource_last_writer[params["sources"]].split(":")
+                G.add_edge(source_node, node_id, source_port=source_port, target_port="labware")
+
+            if "targets" in params:
+                resource_last_writer[params["targets"]] = f"{node_id}:labware"
+
+        # 添加协议结束节点
+        end_id = str(uuid.uuid4())
+        G.add_node(end_id, template=f"{LAB_NAME}-liquid_handler.biomek-run_protocol")
+        if prev_node is not None:
+            G.add_edge(prev_node, end_id, source_port="ready", target_port="ready")
+
+    else:
+        # 有机化学协议图构建
+        WORKSTATION_ID = workstation_name
+
+        # 为所有labware创建资源节点
+        for item_id, item in labware_info.items():
+            # item_id = item.get("id") or item.get("name", f"item_{uuid.uuid4()}")
+            node_id = str(uuid.uuid4())
+
+            # 判断节点类型
+            if item.get("type") == "hardware" or "reactor" in str(item_id).lower():
+                if "reactor" not in str(item_id).lower():
+                    continue
+                lab_node_type = "Sample"
+                description = f"Prepare Reactor: {item_id}"
+                liquid_type = []
+                liquid_volume = []
+            else:
+                lab_node_type = "Reagent"
+                description = f"Add Reagent to Flask: {item_id}"
+                liquid_type = [item_id]
+                liquid_volume = [1e5]
+
+            G.add_node(
+                node_id,
+                template=f"{LAB_NAME}-host_node-create_resource",
+                description=description,
+                lab_node_type=lab_node_type,
+                res_id=item_id,
+                device_id=WORKSTATION_ID,
+                class_name="container",
+                parent=WORKSTATION_ID,
+                bind_locations={"x": 0.0, "y": 0.0, "z": 0.0},
+                liquid_input_slot=[-1],
+                liquid_type=liquid_type,
+                liquid_volume=liquid_volume,
+                slot_on_deck="",
+                role=item.get("role", ""),
+            )
+            resource_last_writer[item_id] = f"{node_id}:labware"
+
+        last_control_node_id = None
+
+        # 处理协议步骤
+        for step in protocol_steps:
+            node_id = str(uuid.uuid4())
+            G.add_node(node_id, **step)
+
+            # 控制流
+            if last_control_node_id is not None:
+                G.add_edge(last_control_node_id, node_id, source_port="ready", target_port="ready")
+            last_control_node_id = node_id
+
+            # 物料流
+            params = step.get("parameters", {})
+            input_resources = {
+                "Vessel": params.get("vessel"),
+                "ToVessel": params.get("to_vessel"),
+                "FromVessel": params.get("from_vessel"),
+                "reagent": params.get("reagent"),
+                "solvent": params.get("solvent"),
+                "compound": params.get("compound"),
+                "sources": params.get("sources"),
+                "targets": params.get("targets"),
+            }
+
+            for target_port, resource_name in input_resources.items():
+                if resource_name and resource_name in resource_last_writer:
+                    source_node, source_port = resource_last_writer[resource_name].split(":")
+                    G.add_edge(source_node, node_id, source_port=source_port, target_port=target_port)
+
+            output_resources = {
+                "VesselOut": params.get("vessel"),
+                "FromVesselOut": params.get("from_vessel"),
+                "ToVesselOut": params.get("to_vessel"),
+                "FiltrateOut": params.get("filtrate_vessel"),
+                "reagent": params.get("reagent"),
+                "solvent": params.get("solvent"),
+                "compound": params.get("compound"),
+                "sources_out": params.get("sources"),
+                "targets_out": params.get("targets"),
+            }
+
+            for source_port, resource_name in output_resources.items():
+                if resource_name:
+                    resource_last_writer[resource_name] = f"{node_id}:{source_port}"
+
+    return G
+
+
+def draw_protocol_graph(protocol_graph: SimpleGraph, output_path: str):
+    """
+    (辅助功能) 使用 networkx 和 matplotlib 绘制协议工作流图，用于可视化。
+    """
+    if not protocol_graph:
+        print("Cannot draw graph: Graph object is empty.")
+        return
+
+    G = nx.DiGraph()
+
+    for node_id, attrs in protocol_graph.nodes.items():
+        label = attrs.get("description", attrs.get("template", node_id[:8]))
+        G.add_node(node_id, label=label, **attrs)
+
+    for edge in protocol_graph.edges:
+        G.add_edge(edge["source"], edge["target"])
+
+    plt.figure(figsize=(20, 15))
+    try:
+        pos = nx.nx_agraph.graphviz_layout(G, prog="dot")
+    except Exception:
+        pos = nx.shell_layout(G)  # Fallback layout
+
+    node_labels = {node: data["label"] for node, data in G.nodes(data=True)}
+    nx.draw(
+        G,
+        pos,
+        with_labels=False,
+        node_size=2500,
+        node_color="skyblue",
+        node_shape="o",
+        edge_color="gray",
+        width=1.5,
+        arrowsize=15,
+    )
+    nx.draw_networkx_labels(G, pos, labels=node_labels, font_size=8, font_weight="bold")
+
+    plt.title("Chemical Protocol Workflow Graph", size=15)
+    plt.savefig(output_path, dpi=300, bbox_inches="tight")
+    plt.close()
+    print(f"  - Visualization saved to '{output_path}'")
+
+
+from networkx.drawing.nx_agraph import to_agraph
+import re
+
+COMPASS = {"n","e","s","w","ne","nw","se","sw","c"}
+
+def _is_compass(port: str) -> bool:
+    return isinstance(port, str) and port.lower() in COMPASS
+
+def draw_protocol_graph_with_ports(protocol_graph, output_path: str, rankdir: str = "LR"):
+    """
+    使用 Graphviz 端口语法绘制协议工作流图。
+    - 若边上的 source_port/target_port 是 compass（n/e/s/w/...），直接用 compass。
+    - 否则自动为节点创建 record 形状并定义命名端口 <portname>。
+    最终由 PyGraphviz 渲染并输出到 output_path（后缀决定格式，如 .png/.svg/.pdf）。
+    """
+    if not protocol_graph:
+        print("Cannot draw graph: Graph object is empty.")
+        return
+
+    # 1) 先用 networkx 搭建有向图，保留端口属性
+    G = nx.DiGraph()
+    for node_id, attrs in protocol_graph.nodes.items():
+        label = attrs.get("description", attrs.get("template", node_id[:8]))
+        # 保留一个干净的“中心标签”，用于放在 record 的中间槽
+        G.add_node(node_id, _core_label=str(label), **{k:v for k,v in attrs.items() if k not in ("label",)})
+
+    edges_data = []
+    in_ports_by_node  = {}  # 收集命名输入端口
+    out_ports_by_node = {}  # 收集命名输出端口
+
+    for edge in protocol_graph.edges:
+        u = edge["source"]
+        v = edge["target"]
+        sp = edge.get("source_port")
+        tp = edge.get("target_port")
+
+        # 记录到图里（保留原始端口信息）
+        G.add_edge(u, v, source_port=sp, target_port=tp)
+        edges_data.append((u, v, sp, tp))
+
+        # 如果不是 compass，就按“命名端口”先归类，等会儿给节点造 record
+        if sp and not _is_compass(sp):
+            out_ports_by_node.setdefault(u, set()).add(str(sp))
+        if tp and not _is_compass(tp):
+            in_ports_by_node.setdefault(v, set()).add(str(tp))
+
+    # 2) 转为 AGraph，使用 Graphviz 渲染
+    A = to_agraph(G)
+    A.graph_attr.update(rankdir=rankdir, splines="true", concentrate="false", fontsize="10")
+    A.node_attr.update(shape="box", style="rounded,filled", fillcolor="lightyellow", color="#999999", fontname="Helvetica")
+    A.edge_attr.update(arrowsize="0.8", color="#666666")
+
+    # 3) 为需要命名端口的节点设置 record 形状与 label
+    #    左列 = 输入端口；中间 = 核心标签；右列 = 输出端口
+    for n in A.nodes():
+        node = A.get_node(n)
+        core = G.nodes[n].get("_core_label", n)
+
+        in_ports  = sorted(in_ports_by_node.get(n, []))
+        out_ports = sorted(out_ports_by_node.get(n, []))
+
+        # 如果该节点涉及命名端口，则用 record；否则保留原 box
+        if in_ports or out_ports:
+            def port_fields(ports):
+                if not ports:
+                    return " "  # 必须留一个空槽占位
+                # 每个端口一个小格子，<p> name
+                return "|".join(f"<{re.sub(r'[^A-Za-z0-9_:.|-]', '_', p)}> {p}" for p in ports)
+
+            left  = port_fields(in_ports)
+            right = port_fields(out_ports)
+
+            # 三栏：左(入) | 中(节点名) | 右(出)
+            record_label = f"{{ {left} | {core} | {right} }}"
+            node.attr.update(shape="record", label=record_label)
+        else:
+            # 没有命名端口：普通盒子，显示核心标签
+            node.attr.update(label=str(core))
+
+    # 4) 给边设置 headport / tailport
+    #    - 若端口为 compass：直接用 compass（e.g., headport="e"）
+    #    - 若端口为命名端口：使用在 record 中定义的 <port> 名（同名即可）
+    for (u, v, sp, tp) in edges_data:
+        e = A.get_edge(u, v)
+
+        # Graphviz 属性：tail 是源，head 是目标
+        if sp:
+            if _is_compass(sp):
+                e.attr["tailport"] = sp.lower()
+            else:
+                # 与 record label 中 <port> 名一致；特殊字符已在 label 中做了清洗
+                e.attr["tailport"] = re.sub(r'[^A-Za-z0-9_:.|-]', '_', str(sp))
+
+        if tp:
+            if _is_compass(tp):
+                e.attr["headport"] = tp.lower()
+            else:
+                e.attr["headport"] = re.sub(r'[^A-Za-z0-9_:.|-]', '_', str(tp))
+
+        # 可选：若想让边更贴边缘，可设置 constraint/spline 等
+        # e.attr["arrowhead"] = "vee"
+
+    # 5) 输出
+    A.draw(output_path, prog="dot")
+    print(f"  - Port-aware workflow rendered to '{output_path}'")
+
+
+def flatten_xdl_procedure(procedure_elem: ET.Element) -> List[ET.Element]:
+    """展平嵌套的XDL程序结构"""
+    flattened_operations = []
+    TEMP_UNSUPPORTED_PROTOCOL = ["Purge", "Wait", "Stir", "ResetHandling"]
+
+    def extract_operations(element: ET.Element):
+        if element.tag not in ["Prep", "Reaction", "Workup", "Purification", "Procedure"]:
+            if element.tag not in TEMP_UNSUPPORTED_PROTOCOL:
+                flattened_operations.append(element)
+
+        for child in element:
+            extract_operations(child)
+
+    for child in procedure_elem:
+        extract_operations(child)
+
+    return flattened_operations
+
+
+def parse_xdl_content(xdl_content: str) -> tuple:
+    """解析XDL内容"""
+    try:
+        xdl_content_cleaned = "".join(c for c in xdl_content if c.isprintable())
+        root = ET.fromstring(xdl_content_cleaned)
+
+        synthesis_elem = root.find("Synthesis")
+        if synthesis_elem is None:
+            return None, None, None
+
+        # 解析硬件组件
+        hardware_elem = synthesis_elem.find("Hardware")
+        hardware = []
+        if hardware_elem is not None:
+            hardware = [{"id": c.get("id"), "type": c.get("type")} for c in hardware_elem.findall("Component")]
+
+        # 解析试剂
+        reagents_elem = synthesis_elem.find("Reagents")
+        reagents = []
+        if reagents_elem is not None:
+            reagents = [{"name": r.get("name"), "role": r.get("role", "")} for r in reagents_elem.findall("Reagent")]
+
+        # 解析程序
+        procedure_elem = synthesis_elem.find("Procedure")
+        if procedure_elem is None:
+            return None, None, None
+
+        flattened_operations = flatten_xdl_procedure(procedure_elem)
+        return hardware, reagents, flattened_operations
+
+    except ET.ParseError as e:
+        raise ValueError(f"Invalid XDL format: {e}")
+
+
+def convert_xdl_to_dict(xdl_content: str) -> Dict[str, Any]:
+    """
+    将XDL XML格式转换为标准的字典格式
+
+    Args:
+        xdl_content: XDL XML内容
+
+    Returns:
+        转换结果，包含步骤和器材信息
+    """
+    try:
+        hardware, reagents, flattened_operations = parse_xdl_content(xdl_content)
+        if hardware is None:
+            return {"error": "Failed to parse XDL content", "success": False}
+
+        # 将XDL元素转换为字典格式
+        steps_data = []
+        for elem in flattened_operations:
+            # 转换参数类型
+            parameters = {}
+            for key, val in elem.attrib.items():
+                converted_val = convert_to_type(val)
+                if converted_val is not None:
+                    parameters[key] = converted_val
+
+            step_dict = {
+                "operation": elem.tag,
+                "parameters": parameters,
+                "description": elem.get("purpose", f"Operation: {elem.tag}"),
+            }
+            steps_data.append(step_dict)
+
+        # 合并硬件和试剂为统一的labware_info格式
+        labware_data = []
+        labware_data.extend({"id": hw["id"], "type": "hardware", **hw} for hw in hardware)
+        labware_data.extend({"name": reagent["name"], "type": "reagent", **reagent} for reagent in reagents)
+
+        return {
+            "success": True,
+            "steps": steps_data,
+            "labware": labware_data,
+            "message": f"Successfully converted XDL to dict format. Found {len(steps_data)} steps and {len(labware_data)} labware items.",
+        }
+
+    except Exception as e:
+        error_msg = f"XDL conversion failed: {str(e)}"
+        logger.error(error_msg)
+        return {"error": error_msg, "success": False}
 
 
 def create_workflow(

setup.py

@@ -4,7 +4,7 @@ package_name = 'unilabos'
 
 setup(
     name=package_name,
-    version='0.11.1',
+    version='0.11.2',
     packages=find_packages(),
     include_package_data=True,
     install_requires=['setuptools'],

unilabos/__init__.py

@@ -1 +1 @@
-__version__ = "0.11.1"
+__version__ = "0.11.2"

unilabos/app/utils.py

@@ -10,29 +10,170 @@ import shutil
 import sys
 
 
+_PATCH_MARKER = "# UniLabOS DLL Patch"
+_PATCH_END_MARKER = "# End UniLabOS DLL Patch"
+
+# 75 = EX_TEMPFAIL: 临时失败、重试即可，避免与业务退出码冲突
+_RESTART_EXIT_CODE = 75
+
+
+def _build_dll_patch(lib_bin: str, preload_pyd: str = "") -> str:
+    """生成一段加在目标文件顶部的 DLL 加载补丁源码。
+
+    - 始终把 ``lib_bin`` 加入 DLL 搜索路径，并把 handle 挂在模块属性上，
+      防止 GC 清掉搜索路径（``os.add_dll_directory`` 的句柄被回收时
+      目录会被移除）。
+    - 可选地用 ``ctypes.CDLL`` 预加载一个 .pyd，把它的依赖 DLL 提前装入
+      进程内存，作为 ``rclpy._rclpy_pybind11`` 这类首次加载点的兜底。
+    """
+    # 用 repr() 序列化路径：Python 解析 repr 的结果会还原成原始字符串，
+    # 不需要也不能再叠加 raw-string 前缀（叠了反而会让 \\ 变成两个反斜杠）。
+    lines = [
+        _PATCH_MARKER,
+        "import os as _ulab_os",
+        f"_ulab_p = {lib_bin!r}",
+        'if hasattr(_ulab_os, "add_dll_directory") and _ulab_os.path.isdir(_ulab_p):',
+        "    try: _UNILAB_DLL_HANDLE = _ulab_os.add_dll_directory(_ulab_p)",
+        "    except Exception: _UNILAB_DLL_HANDLE = None",
+    ]
+    if preload_pyd:
+        lines.extend(
+            [
+                "import ctypes as _ulab_ctypes",
+                f"try: _ulab_ctypes.CDLL({preload_pyd!r})",
+                "except Exception: pass",
+            ]
+        )
+    lines.append(_PATCH_END_MARKER)
+    return "\n".join(lines) + "\n"
+
+
+def _apply_dll_patch(file_path: str, lib_bin: str, preload_pyd: str = "") -> bool:
+    """把 DLL 补丁前置到 ``file_path``。文件不存在或已打过补丁则返回 False。"""
+    if not os.path.isfile(file_path):
+        return False
+    with open(file_path, "r", encoding="utf-8") as f:
+        content = f.read()
+    if _PATCH_MARKER in content:
+        return False
+    shutil.copy2(file_path, file_path + ".bak")
+    with open(file_path, "w", encoding="utf-8") as f:
+        f.write(_build_dll_patch(lib_bin, preload_pyd) + content)
+    return True
+
+
+def _print_restart_banner(patched_files):
+    """打印重启提示并以 EX_TEMPFAIL 退出。
+
+    - 不使用 ANSI 颜色码：Windows 旧版 cmd / PowerShell 5 默认不开 VT 处理，
+      会把 ``\\033[1;33m`` 当做字面字符显示，反而让用户看不到正文。
+    - 同时写入 stderr 与 stdout：某些上层 launcher / supervisor 只重定向
+      其中一路，写两遍能保证用户至少看到一份。
+    - 写入前防御性把流切到 UTF-8 with replace：``main.py`` 里已经做过一次，
+      但本模块也可能被绕过 ``main.py`` 的代码路径直接 import；reconfigure
+      失败也只是退回 errors=replace，不影响整体流程。
+    """
+    if sys.platform == "win32":
+        for _stream in (sys.stdout, sys.stderr):
+            try:
+                _stream.reconfigure(encoding="utf-8", errors="replace")  # type: ignore[attr-defined]
+            except (AttributeError, OSError):
+                pass
+
+    bar = "#" * 78
+    files_lines = [f"[UniLabOS]   - {p}" for p in patched_files]
+    body = "\n".join(
+        [
+            "",
+            bar,
+            bar,
+            "##",
+            "##  [UniLabOS] Windows + conda 下检测到 DLL 加载失败，已自动打补丁。",
+            "##  [UniLabOS] DLL load failure detected on Windows + conda;",
+            "##  [UniLabOS] the following files have been auto-patched:",
+            "##",
+            *[f"##  {line}" for line in files_lines],
+            "##",
+            "##  [UniLabOS] 当前进程的 rclpy 状态已损坏，补丁需要在新进程才生效。",
+            "##  [UniLabOS] The current process is unusable; the patch only takes",
+            "##  [UniLabOS] effect on a fresh process.",
+            "##",
+            "##  >>> 请重新运行刚才的命令 / Please re-run the same command. <<<",
+            "##",
+            bar,
+            bar,
+            "",
+        ]
+    )
+
+    for stream in (sys.stderr, sys.stdout):
+        try:
+            stream.write(body)
+            stream.flush()
+        except Exception:
+            try:
+                print(body, file=stream)
+            except Exception:
+                pass
+
+    sys.exit(_RESTART_EXIT_CODE)
+
+
 def patch_rclpy_dll_windows():
-    """在 Windows + conda 环境下为 rclpy 打 DLL 加载补丁"""
+    """在 Windows + conda 环境下修复 rclpy / rosidl typesupport 的 DLL 加载。
+
+    背景：conda 安装的 ros 系列包，其原生扩展依赖 ``$CONDA_PREFIX/Library/bin``
+    下的 DLL；只有 conda 环境被正确激活、且 PATH 中含 ``Library/bin`` 时，
+    ``os.add_dll_directory`` 才能找到它们。当从快捷方式 / IDE / 子进程 /
+    没激活的 shell 启动 ``unilab`` 时，会出现 ``DLL load failed``。
+
+    本函数会:
+        1) 修补 ``rclpy/impl/implementation_singleton.py`` —— rclpy 自身的 C 扩展入口；
+        2) 修补 ``rpyutils/add_dll_directories.py`` —— 所有 ``*_s__rosidl_typesupport_c.pyd``
+           （``geometry_msgs`` / ``std_msgs`` / ``sensor_msgs`` 等）的统一加载入口。
+
+    打完补丁后**必须重启进程**才能生效（当前进程的 rclpy 已经发生过
+    ``ImportError``，子模块仍处于损坏状态）。因此函数会主动退出，并在
+    stdout/stderr 同时打印明显的重启提示，避免用户被后续报错淹没。
+    """
     if sys.platform != "win32" or not os.environ.get("CONDA_PREFIX"):
         return
+
     try:
-        import rclpy
+        import rclpy  # noqa: F401
 
         return
     except ImportError as e:
         if not str(e).startswith("DLL load failed"):
             return
+
     cp = os.environ["CONDA_PREFIX"]
-    impl = os.path.join(cp, "Lib", "site-packages", "rclpy", "impl", "implementation_singleton.py")
-    pyd = glob.glob(os.path.join(cp, "Lib", "site-packages", "rclpy", "_rclpy_pybind11*.pyd"))
-    if not os.path.exists(impl) or not pyd:
+    lib_bin = os.path.join(cp, "Library", "bin")
+    site_packages = os.path.join(cp, "Lib", "site-packages")
+    if not os.path.isdir(lib_bin):
         return
-    with open(impl, "r", encoding="utf-8") as f:
-        content = f.read()
-    lib_bin = os.path.join(cp, "Library", "bin").replace("\\", "/")
-    patch = f'# UniLabOS DLL Patch\nimport os,ctypes\nos.add_dll_directory("{lib_bin}") if hasattr(os,"add_dll_directory") else None\ntry: ctypes.CDLL("{pyd[0].replace(chr(92),"/")}")\nexcept: pass\n# End Patch\n'
-    shutil.copy2(impl, impl + ".bak")
-    with open(impl, "w", encoding="utf-8") as f:
-        f.write(patch + content)
+
+    patched = []
+
+    # 1) rclpy 自身的入口
+    rclpy_impl = os.path.join(site_packages, "rclpy", "impl", "implementation_singleton.py")
+    rclpy_pyd_matches = glob.glob(os.path.join(site_packages, "rclpy", "_rclpy_pybind11*.pyd"))
+    rclpy_pyd = rclpy_pyd_matches[0] if rclpy_pyd_matches else ""
+    if rclpy_pyd and _apply_dll_patch(rclpy_impl, lib_bin, preload_pyd=rclpy_pyd):
+        patched.append(rclpy_impl)
+
+    # 2) rpyutils —— 所有 rosidl typesupport pyd 的加载点；放在 rclpy 之后
+    #    例：geometry_msgs/geometry_msgs_s__rosidl_typesupport_c.pyd
+    rpyutils_dll = os.path.join(site_packages, "rpyutils", "add_dll_directories.py")
+    if _apply_dll_patch(rpyutils_dll, lib_bin):
+        patched.append(rpyutils_dll)
+
+    if not patched:
+        # 已经打过补丁但 rclpy 仍然加载失败：原因不是缺 DLL 搜索路径，
+        # 不要再次打补丁污染文件，让上层看到真实的 ImportError。
+        return
+
+    _print_restart_banner(patched)
 
 
 patch_rclpy_dll_windows()

unilabos/devices/workstation/bioyond_studio/bioyond_rpc.py

@@ -779,49 +779,6 @@ class BioyondV1RPC(BaseRequest):
 
         return response.get("data", {})
 
-    def take_out(
-        self,
-        order_id: str,
-        preintake_ids: list[str] | None = None,
-        material_ids: list[str] | None = None,
-    ) -> dict:
-        """取出订单关联通量/物料
-
-        参数:
-            order_id: 订单ID
-            preintake_ids: 通量ID列表，可为空
-            material_ids: 物料ID列表，可为空
-
-        返回值:
-            dict: 服务端响应包，失败返回空字典
-        """
-        if not order_id:
-            self._logger.error("取出订单关联通量/物料错误: 缺少订单ID")
-            return {}
-
-        params = {
-            "orderId": order_id,
-            "preintakeIds": list(preintake_ids or []),
-            "materialIds": list(material_ids or []),
-        }
-
-        response = self.post(
-            url=f'{self.host}/api/lims/order/take-out',
-            params={
-                "apiKey": self.api_key,
-                "requestTime": self.get_current_time_iso8601(),
-                "data": params,
-            })
-
-        if not response:
-            return {}
-
-        if response['code'] != 1:
-            self._logger.error(f"取出订单关联通量/物料错误: {response.get('message', '')}")
-            return response
-
-        return response
-
     def cancel_order(self, json_str: str) -> bool:
         """取消指定任务
 

unilabos/devices/workstation/bioyond_studio/debug_call_log.py

@@ -1,459 +0,0 @@
-"""Per-action raw call/response log for Bioyond stations.
-
-When a debug session is active, ``wrap_rpc_http`` replaces a ``BioyondV1RPC``
-instance's ``post`` / ``get`` methods with closures that perform the HTTP
-transport themselves, capture the request/response details, and append a record
-to the active session before returning exactly what ``BaseRequest`` would have
-returned. Outside of an active session the wrapped method delegates to the
-original (unwrapped) implementation, leaving non-debug behavior intact.
-
-The session writes a Markdown file under ``out_dir`` mirroring the format of
-``bioyond_debug_records/2026-04-30_160316_day3_samplefile_only_raw_calls.md``
-minus the "Raw Payload Argument" section.
-
-This module has no dependency on ``BioyondV1RPC`` itself; the only contract is
-that the wrapped instance descends from ``BaseRequest`` (i.e. has a logger
-returned by ``self.get_logger()``).
-"""
-
-from __future__ import annotations
-
-import contextvars
-import copy
-import inspect
-import json
-import re
-from contextlib import contextmanager
-from dataclasses import dataclass, field
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Iterator, List, Optional
-
-import requests
-
-__all__ = [
-    "CallRecord",
-    "CallLogContext",
-    "session",
-    "wrap_rpc_http",
-    "active_session",
-]
-
-
-_DEFAULT_TIMEOUT_GET = 30
-_DEFAULT_TIMEOUT_POST = 120
-
-
-@dataclass
-class CallRecord:
-    """One captured HTTP call inside a debug session."""
-
-    index: int
-    method: str
-    url: str
-    path: str
-    source: str
-    transport: str
-    http_status: Optional[int]
-    request_body: Any
-    response_body: Any
-    error: Optional[str] = None
-
-
-@dataclass
-class CallLogContext:
-    """State for a single ``session()`` block.
-
-    A session lazily creates its file on the first appended record. Actions
-    that abort before any RPC produce no file.
-    """
-
-    action: str
-    out_dir: Path
-    started_at: datetime
-    calls: List[CallRecord] = field(default_factory=list)
-    file_path: Optional[Path] = None
-
-    def append(self, record: CallRecord) -> None:
-        record.index = len(self.calls) + 1
-        self.calls.append(record)
-        self._write_file()
-
-    # -- file I/O -------------------------------------------------------------
-
-    def _resolve_file_path(self) -> Path:
-        if self.file_path is not None:
-            return self.file_path
-        timestamp = self.started_at.strftime("%Y-%m-%d_%H%M%S")
-        slug = _slugify_action(self.action)
-        candidate = self.out_dir / f"{timestamp}_{slug}_raw_calls.md"
-        suffix = 2
-        while candidate.exists():
-            candidate = (
-                self.out_dir
-                / f"{timestamp}_{slug}_raw_calls_{suffix:02d}.md"
-            )
-            suffix += 1
-        self.file_path = candidate
-        return self.file_path
-
-    def _write_file(self) -> None:
-        path = self._resolve_file_path()
-        path.parent.mkdir(parents=True, exist_ok=True)
-        path.write_text(_render_markdown(self), encoding="utf-8")
-
-
-_active_session: contextvars.ContextVar[Optional[CallLogContext]] = (
-    contextvars.ContextVar("_active_session", default=None)
-)
-
-
-def active_session() -> Optional[CallLogContext]:
-    """Return the currently active :class:`CallLogContext`, if any."""
-    return _active_session.get()
-
-
-@contextmanager
-def session(action: str, out_dir: Path) -> Iterator[CallLogContext]:
-    """Open a per-action debug session.
-
-    On entry, sets the module-level ``_active_session`` ContextVar so any
-    ``wrap_rpc_http``'d clients on the same thread/task record their calls.
-    On exit, the previous active session (if any) is restored.
-    """
-    ctx = CallLogContext(
-        action=str(action),
-        out_dir=Path(out_dir),
-        started_at=datetime.now(),
-    )
-    token = _active_session.set(ctx)
-    try:
-        yield ctx
-    finally:
-        _active_session.reset(token)
-
-
-def wrap_rpc_http(rpc: Any) -> None:
-    """Idempotently wrap ``rpc.post`` / ``rpc.get``.
-
-    When a session is active (``_active_session.get() is not None``), the
-    wrapped methods perform the HTTP call themselves with ``requests`` and
-    record the call before returning the same value ``BaseRequest`` would have
-    returned. When no session is active, the wrapped methods delegate to the
-    original implementation, preserving stock ``BaseRequest`` behavior.
-
-    Calling this twice on the same instance is a no-op. The wrapper does not
-    alter ``rpc.form_post`` (no Sirna action calls it as of plan 3).
-    """
-    if rpc is None:
-        return
-    if getattr(rpc, "_debug_call_log_wrapped", False):
-        return
-
-    rpc._orig_post = rpc.post
-    rpc._orig_get = rpc.get
-
-    def _wrapped_post(
-        url: str,
-        params: Any = None,
-        files: Any = None,
-        headers: Optional[dict] = None,
-    ) -> Any:
-        ctx = _active_session.get()
-        if ctx is None:
-            kwargs = {}
-            if params is not None:
-                kwargs["params"] = params
-            if files is not None:
-                kwargs["files"] = files
-            if headers is not None:
-                kwargs["headers"] = headers
-            return rpc._orig_post(url, **kwargs)
-        effective_params = params if params is not None else {}
-        effective_headers = (
-            headers
-            if headers is not None
-            else {"Content-Type": "application/json"}
-        )
-        source = _detect_source(rpc)
-        request_body = _redact(effective_params)
-        record = CallRecord(
-            index=0,
-            method="POST",
-            url=str(url),
-            path=_url_path(url),
-            source=source,
-            transport=_pick_transport(effective_params),
-            http_status=None,
-            request_body=request_body,
-            response_body=None,
-            error=None,
-        )
-        return_value: Any = None
-        try:
-            response = requests.post(
-                url,
-                data=json.dumps(effective_params) if effective_params else None,
-                headers=effective_headers,
-                timeout=_DEFAULT_TIMEOUT_POST,
-                files=files,
-            )
-        except Exception as exc:  # pragma: no cover - delegated to logger
-            record.error = f"transport error: {exc}"
-            try:
-                rpc.get_logger().error(f"Request ERROR: {exc}")
-            except Exception:
-                pass
-            ctx.append(record)
-            return None
-
-        record.http_status = response.status_code
-        record.response_body, parse_error = _decode_response_body(response)
-        try:
-            rpc.get_logger().debug(
-                f"Request >>> : {response.request.body} "
-                f"{response.status_code} {response.text}"
-            )
-        except Exception:
-            pass
-
-        if response.status_code == 200:
-            if parse_error is not None:
-                record.error = f"json parse error: {parse_error}"
-                return_value = None
-            else:
-                return_value = record.response_body
-        else:
-            record.error = f"HTTP {response.status_code}: {response.text}"
-            try:
-                rpc.get_logger().error(
-                    f"Request ERROR: ('Request ERROR:', {response.text!r})"
-                )
-            except Exception:
-                pass
-            return_value = None
-
-        ctx.append(record)
-        return return_value
-
-    def _wrapped_get(
-        url: str,
-        params: Any = None,
-        headers: Optional[dict] = None,
-    ) -> Any:
-        ctx = _active_session.get()
-        if ctx is None:
-            kwargs = {}
-            if params is not None:
-                kwargs["params"] = params
-            if headers is not None:
-                kwargs["headers"] = headers
-            return rpc._orig_get(url, **kwargs)
-        effective_params = params if params is not None else {}
-        effective_headers = (
-            headers
-            if headers is not None
-            else {"Content-Type": "application/json"}
-        )
-        source = _detect_source(rpc)
-        request_body = _redact(effective_params)
-        record = CallRecord(
-            index=0,
-            method="GET",
-            url=str(url),
-            path=_url_path(url),
-            source=source,
-            transport="params",
-            http_status=None,
-            request_body=request_body,
-            response_body=None,
-            error=None,
-        )
-        return_value: Any = None
-        try:
-            response = requests.get(
-                url,
-                params=effective_params,
-                headers=effective_headers,
-                timeout=_DEFAULT_TIMEOUT_GET,
-            )
-        except Exception as exc:  # pragma: no cover - delegated to logger
-            record.error = f"transport error: {exc}"
-            try:
-                rpc.get_logger().error(f"Request ERROR: {exc}")
-            except Exception:
-                pass
-            ctx.append(record)
-            return None
-
-        record.http_status = response.status_code
-        record.response_body, parse_error = _decode_response_body(response)
-        try:
-            rpc.get_logger().debug(
-                f"Request >>> : {effective_params} "
-                f"{response.status_code} {response.text}"
-            )
-        except Exception:
-            pass
-
-        if response.status_code == 200:
-            if parse_error is not None:
-                record.error = f"json parse error: {parse_error}"
-                return_value = None
-            else:
-                return_value = record.response_body
-
-        ctx.append(record)
-        return return_value
-
-    rpc.post = _wrapped_post
-    rpc.get = _wrapped_get
-    rpc._debug_call_log_wrapped = True
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-
-_URL_PATH_RE = re.compile(r"https?://[^/]+(/.*)?$")
-_SLUG_RE = re.compile(r"[^A-Za-z0-9._-]+")
-
-
-def _slugify_action(action: str) -> str:
-    slug = _SLUG_RE.sub("_", str(action)).strip("_")
-    return slug or "action"
-
-
-def _url_path(url: Any) -> str:
-    text = str(url or "")
-    match = _URL_PATH_RE.match(text)
-    if match and match.group(1):
-        return match.group(1)
-    if text.startswith("/"):
-        return text
-    return text
-
-
-def _pick_transport(params: Any) -> str:
-    if isinstance(params, dict) and "data" in params:
-        return "data"
-    return "params"
-
-
-def _detect_source(rpc: Any) -> str:
-    """Walk the call stack to find the outermost frame whose ``self`` is rpc."""
-    try:
-        stack = inspect.stack()
-    except Exception:
-        return ""
-    candidate = ""
-    try:
-        for frame_info in stack:
-            frame = frame_info.frame
-            if frame.f_locals.get("self", None) is rpc:
-                candidate = frame_info.function
-        return candidate
-    finally:
-        del stack
-
-
-def _redact(params: Any) -> Any:
-    """Return a copy of ``params`` with ``apiKey`` redacted."""
-    try:
-        cloned = copy.deepcopy(params)
-    except Exception:
-        return params
-    _redact_in_place(cloned)
-    return cloned
-
-
-def _redact_in_place(value: Any) -> None:
-    if isinstance(value, dict):
-        for key in list(value.keys()):
-            if isinstance(key, str) and key.lower() == "apikey":
-                value[key] = "<redacted>"
-            else:
-                _redact_in_place(value[key])
-    elif isinstance(value, list):
-        for item in value:
-            _redact_in_place(item)
-
-
-def _decode_response_body(response: Any) -> tuple[Any, Optional[str]]:
-    """Best-effort response decoding used for both record + return value."""
-    text = getattr(response, "text", "")
-    try:
-        return response.json(), None
-    except Exception as exc:
-        if text:
-            return {"raw_text": text}, str(exc)
-        return None, str(exc)
-
-
-# ---------------------------------------------------------------------------
-# Markdown rendering
-# ---------------------------------------------------------------------------
-
-
-def _render_markdown(ctx: CallLogContext) -> str:
-    title = f"# {ctx.action} Raw Call/Response Log"
-    parts: List[str] = [title, ""]
-    parts.append("## LIMS Calls")
-    parts.append("")
-    parts.append("| # | Method | Path | Source | HTTP |")
-    parts.append("|---|---|---|---|---|")
-    for record in ctx.calls:
-        anchor = _row_anchor(record)
-        http = (
-            f"`{record.http_status}`"
-            if record.http_status is not None
-            else "`-`"
-        )
-        parts.append(
-            f"| [{record.index}](#{anchor}) | `{record.method}` | "
-            f"`{record.path}` | `{record.source}` | {http} |"
-        )
-    parts.append("")
-
-    for record in ctx.calls:
-        parts.append(f"## {record.index} {record.method} {record.path}")
-        parts.append("")
-        parts.append(f"- Source: `{record.source}`")
-        parts.append(f"- Transport: `{record.transport}`")
-        if record.http_status is not None:
-            parts.append(f"- HTTP status: `{record.http_status}`")
-        else:
-            parts.append("- HTTP status: `-`")
-        if record.error:
-            parts.append(f"- Error: {record.error}")
-        parts.append("")
-        parts.append("### Request Body")
-        parts.append("")
-        parts.append("```json")
-        parts.append(_to_json_block(record.request_body))
-        parts.append("```")
-        parts.append("")
-        parts.append("### Response Body")
-        parts.append("")
-        parts.append("```json")
-        parts.append(_to_json_block(record.response_body))
-        parts.append("```")
-        parts.append("")
-
-    return "\n".join(parts).rstrip() + "\n"
-
-
-def _row_anchor(record: CallRecord) -> str:
-    """Build a GitHub-style anchor matching ``## N METHOD /path``."""
-    raw = f"{record.index}-{record.method}-{record.path}"
-    raw = raw.lower()
-    raw = re.sub(r"[^a-z0-9]+", "-", raw)
-    return raw.strip("-")
-
-
-def _to_json_block(value: Any) -> str:
-    try:
-        return json.dumps(value, ensure_ascii=False, indent=2, sort_keys=True)
-    except TypeError:
-        return json.dumps(str(value), ensure_ascii=False, indent=2)

unilabos/devices/workstation/bioyond_studio/peptide_station/__init__.py

@@ -1,3 +0,0 @@
-from .peptide_station import BioyondPeptideStation, fetch_workflow_list, load_peptide_config
-
-__all__ = ["BioyondPeptideStation", "fetch_workflow_list", "load_peptide_config"]

unilabos/devices/workstation/bioyond_studio/peptide_station/tests/test_peptide_station_contracts.py

@@ -1,681 +0,0 @@
-"""多肽站 AST/参数/结果表 离线契约测试。"""
-
-from __future__ import annotations
-
-import importlib
-import inspect
-import json
-import sys
-from pathlib import Path
-from typing import Any, Dict, List
-from unittest.mock import MagicMock
-
-import pytest
-
-REPO_ROOT = Path(__file__).resolve().parents[6]
-if str(REPO_ROOT) not in sys.path:
-    sys.path.insert(0, str(REPO_ROOT))
-
-MODULE_PATH = "unilabos.devices.workstation.bioyond_studio.peptide_station.peptide_station"
-CLASS_NAME = "BioyondPeptideStation"
-
-ORDER_GUID = "3a20eabe-bad5-ef95-49bd-7ffbd5df189d"
-CREATE_ALLOCATION = {
-    ORDER_GUID: [
-        {
-            "materialId": "mat-tip",
-            "materialName": "200μL枪头盒",
-            "materialCode": "0008-00105",
-            "quantity": "1个",
-            "materialTypeMode": "Consumables",
-            "locationCode": "1-01",
-            "locationShowName": "1-01",
-        },
-        {
-            "materialId": "mat-plate",
-            "materialName": "96孔板",
-            "materialCode": "PLATE-96",
-            "quantity": "1",
-            "materialTypeMode": "Sample",
-            "locationCode": "A1",
-            "locationShowName": "A1-show",
-        },
-        {
-            "materialId": "mat-extra",
-            "materialName": "未知耗材",
-            "materialCode": "X-1",
-            "quantity": "2",
-            "materialTypeMode": "Future",
-            "locationCode": "Z9",
-            "locationShowName": "",
-        },
-    ]
-}
-
-FLATTENED_LIVE = [
-    {"step": "39c78d4b-b5d3-f721-2001-9d52000084c3", "step_name": "S1", "Key": "SampleFile", "m": 0, "n": 0, "Value": "", "DisplayValue": "", "TaskDisplayable": 1},
-    {"step": "39c78d4b-b5d3-f721-2001-9d52000084c3", "step_name": "S1", "Key": "Example", "m": 0, "n": 0, "Value": "x", "DisplayValue": "x", "TaskDisplayable": 1},
-    {"step": "39c78d4b-b5d3-f721-2001-9d52000084c4", "step_name": "S2", "Key": "protocol", "m": 14, "n": 28, "Value": "", "DisplayValue": "", "TaskDisplayable": 1},
-    {"step": "39c78d4b-b5d3-f721-2001-9d52000084c5", "step_name": "S3", "Key": "CEMMethodFileName", "m": 0, "n": 0, "Value": "", "DisplayValue": "", "TaskDisplayable": 1},
-]
-
-
-def _import_module() -> Any:
-    return importlib.import_module(MODULE_PATH)
-
-
-def _make_station() -> Any:
-    module = _import_module()
-    cls = getattr(module, CLASS_NAME)
-    station = object.__new__(cls)
-    station.bioyond_config = {"api_host": "http://test", "api_key": "k", "warehouse_mapping": {}}
-    rpc = MagicMock()
-    rpc.host = "http://test"
-    rpc.api_key = "k"
-    rpc.material_info.return_value = {"locations": [{"whName": "自动化堆栈", "code": "1-01"}]}
-    station.hardware_interface = rpc
-    return station
-
-
-# ---------------------------------------------------------------------------
-# 1. AST/导入面
-# ---------------------------------------------------------------------------
-
-
-def test_required_actions_exposed() -> None:
-    cls = getattr(_import_module(), CLASS_NAME)
-    required = {
-        "upload_sample_excel",
-        "list_sample_excels",
-        "get_step_parameters",
-        "submit_experiment",
-        "submit_experiment_day1",
-        "submit_experiment_day2",
-        "submit_experiment_day3",
-        "submit_experiment_day4",
-        "submit_experiment_day4_LCMS",
-        "start_experiment",
-        "reset",
-        "scheduler_start",
-        "scheduler_stop",
-        "scheduler_pause",
-        "scheduler_continue",
-        "get_order_list",
-        "get_order_report",
-        "get_aggregated_order_report",
-    }
-    have = {name for name, _ in inspect.getmembers(cls, inspect.isfunction)}
-    missing = sorted(required - have)
-    assert not missing, f"缺少动作: {missing}"
-
-
-def test_manual_confirm_node_types() -> None:
-    module = _import_module()
-    cls = getattr(module, CLASS_NAME)
-    manual = {"submit_experiment_day1", "start_experiment"}
-    normal = {
-        "submit_experiment",
-        "submit_experiment_day2",
-        "submit_experiment_day3",
-        "submit_experiment_day4",
-        "submit_experiment_day4_LCMS",
-        "reset",
-        "scheduler_start",
-        "list_sample_excels",
-        "get_step_parameters",
-        "get_order_list",
-        "get_order_report",
-    }
-    for name in manual:
-        meta = getattr(getattr(cls, name), "_action_registry_meta", {})
-        assert meta.get("node_type") == module.NodeType.MANUAL_CONFIRM, name
-    for name in normal:
-        meta = getattr(getattr(cls, name), "_action_registry_meta", {})
-        assert meta.get("node_type") != module.NodeType.MANUAL_CONFIRM, name
-
-
-def test_submit_and_reset_signatures_exclude_legacy_manual_confirm() -> None:
-    cls = getattr(_import_module(), CLASS_NAME)
-    for name in (
-        "submit_experiment",
-        "submit_experiment_day2",
-        "submit_experiment_day3",
-        "submit_experiment_day4",
-        "submit_experiment_day4_LCMS",
-        "reset",
-    ):
-        params = inspect.signature(getattr(cls, name)).parameters
-        assert "timeout_seconds" not in params, name
-        assert "assignee_user_ids" not in params, name
-
-
-def test_day1_submit_accepts_manual_confirm_kwargs() -> None:
-    """plan: Day1 是 MANUAL_CONFIRM；框架会注入 timeout_seconds/assignee_user_ids，函数必须能接收。"""
-    cls = getattr(_import_module(), CLASS_NAME)
-    sig = inspect.signature(cls.submit_experiment_day1)
-    has_kwargs = any(p.kind == inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values())
-    assert has_kwargs, "submit_experiment_day1 必须有 **kwargs 以容纳人工确认框架字段"
-
-
-def test_typed_dicts_present() -> None:
-    module = _import_module()
-    for cls_name in (
-        "PeptideGenericSubmitRequiredParams",
-        "PeptideGenericSubmitOptionalParams",
-        "PeptideDay1RequiredParams",
-        "PeptideDay1OptionalParams",
-        "PeptideDay2RequiredParams",
-        "PeptideDay2OptionalParams",
-        "PeptideDay3RequiredParams",
-        "PeptideDay3OptionalParams",
-        "PeptideDay4RequiredParams",
-        "PeptideDay4OptionalParams",
-        "PeptideDay4LCMSRequiredParams",
-        "PeptideDay4LCMSOptionalParams",
-    ):
-        assert hasattr(module, cls_name), cls_name
-
-
-def test_workflow_constants_split() -> None:
-    module = _import_module()
-    assert module.DAY4_PEPTIDE_WORKFLOW_NAME == "Day4环肽酰化-酶标"
-    assert module.DAY4_LCMS_PEPTIDE_WORKFLOW_NAME == "Day4环肽酰化-酶标+LCMS"
-    assert module.DAY_WORKFLOW_BINDINGS["day4_lcms"]["sub_name"] == "Day4环肽酰化-酶标LCMS"
-    assert module.DAY1_CEM_METHOD_DEFAULT == "5microdouble-20250911.MPM"
-
-
-# ---------------------------------------------------------------------------
-# 2. Sample Excel
-# ---------------------------------------------------------------------------
-
-
-def test_list_sample_excels_modes() -> None:
-    station = _make_station()
-    records = [
-        {"fileName": "DPR019-a.xlsx", "relativePath": "upload\\sample\\DPR019-a.xlsx"},
-        {"fileName": "DPR019-b.xlsx", "relativePath": "upload\\sample\\DPR019-b.xlsx"},
-    ]
-    station._list_sample_excels = MagicMock(return_value=records)  # type: ignore[method-assign]
-
-    info = station.list_sample_excels(sample_excel_pattern="DPR019-a", deterministic_resolve=False)
-    assert "sample_excel_data" in info
-    assert "sample_excel_relative_path" not in info
-
-    resolved = station.list_sample_excels(sample_excel_pattern="DPR019-a", deterministic_resolve=True)
-    assert resolved["sample_excel_relative_path"] == "upload\\sample\\DPR019-a.xlsx"
-
-    with pytest.raises(Exception):
-        station.list_sample_excels(sample_excel_pattern="DPR019", deterministic_resolve=True)
-
-
-def test_resolve_submit_sample_file_direct_path() -> None:
-    station = _make_station()
-    relative, selected = station._resolve_submit_sample_file({}, {}, "upload/sample/x.xlsx")
-    assert relative == "upload\\sample\\x.xlsx"
-    assert selected["fileName"] == "x.xlsx"
-
-
-def test_filename_matches_pattern_substring_and_glob() -> None:
-    station = _make_station()
-    assert station._filename_matches_pattern("DPR019-20260421-thrombin-5.xlsx", "DPR019")
-    assert station._filename_matches_pattern("a.xlsx", "*.xlsx")
-    assert not station._filename_matches_pattern("a.xlsx", "*.docx")
-    assert station._filename_matches_pattern("a.xlsx", "")
-
-
-# ---------------------------------------------------------------------------
-# 3. Step parameter helper
-# ---------------------------------------------------------------------------
-
-
-def test_filter_step_parameters_preserves_zero_and_skips_unknown() -> None:
-    station = _make_station()
-    records = [
-        {"TaskDisplayable": 1, "Value": 0, "DisplayValue": ""},
-        {"TaskDisplayable": 1, "Value": "", "DisplayValue": ""},
-        {"TaskDisplayable": 0, "Value": "", "DisplayValue": ""},
-        {"TaskDisplayable": None, "Value": "", "DisplayValue": ""},
-    ]
-    filtered = station._filter_step_parameter_records(records, True, True, True)
-    assert {(r.get("Value"), r.get("TaskDisplayable")) for r in filtered} == {(0, 1), ("", 1), ("", 0)}
-
-
-def test_get_step_parameters_zero_match_returns_status() -> None:
-    station = _make_station()
-    station._query_workflow_records = MagicMock(return_value=[])  # type: ignore[method-assign]
-    out = station.get_step_parameters(workflow_name_filter="不存在")
-    status = out["step_parameters_raw_json"]
-    assert status.get("code") == -1
-    assert out["filtered_subworkflows"] == []
-
-
-def test_get_step_parameters_multi_match_returns_status() -> None:
-    station = _make_station()
-    station._query_workflow_records = MagicMock(return_value=[  # type: ignore[method-assign]
-        {"workflowId": "w1", "workflowName": "A", "subworkflowId": "s1", "subworkflowName": "A1"},
-        {"workflowId": "w1", "workflowName": "A", "subworkflowId": "s2", "subworkflowName": "A2"},
-    ])
-    out = station.get_step_parameters(workflow_name_filter="A")
-    assert out["step_parameters_raw_json"].get("code") == 0
-    assert len(out["filtered_subworkflows"]) == 2
-
-
-def test_get_step_parameters_direct_sub_workflow_id() -> None:
-    station = _make_station()
-    station._query_step_parameters = MagicMock(return_value={  # type: ignore[method-assign]
-        "39c78d4b-b5d3-f721-2001-9d52000084c3": [
-            {"name": "S1", "m": 0, "n": 0, "parameterList": [
-                {"Key": "SampleFile", "TaskDisplayable": 1, "Value": "", "DisplayValue": ""},
-            ]},
-        ]
-    })
-    out = station.get_step_parameters(sub_workflow_id="39c78d4b-b5d3-f721-2001-9d52000084c3")
-    augmented = out["step_parameters_raw_json"]
-    assert augmented["code"] == 1
-    assert any(p["Key"] == "SampleFile" for p in augmented["data"]["filteredParameters"])
-
-
-# ---------------------------------------------------------------------------
-# 4. Partial parameter entries + live resolution
-# ---------------------------------------------------------------------------
-
-
-def test_partial_entries_inject_samplefile_and_overrides() -> None:
-    station = _make_station()
-    entries, warnings = station._build_partial_parameter_entries(
-        sample_excel_relative_path="upload\\sample\\f.xlsx",
-        day_key="day2",
-        parameter_overrides=[{"Key": "Example", "Value": 0}],
-    )
-    assert entries[0] == {"Key": "SampleFile", "Value": "upload\\sample\\f.xlsx"}
-    assert any(e["Key"] == "Example" and e["Value"] == 0 for e in entries)
-    assert warnings == []
-
-
-def test_day1_partial_entries_inject_cem_default() -> None:
-    station = _make_station()
-    entries, _ = station._build_partial_parameter_entries(
-        sample_excel_relative_path="upload\\sample\\f.xlsx",
-        day_key="day1",
-        extra_autofill=[{"Key": "CEMMethodFileName", "Value": "5microdouble-20250911.MPM"}],
-    )
-    assert any(e["Key"] == "CEMMethodFileName" and e["Value"] == "5microdouble-20250911.MPM" for e in entries)
-
-
-def test_overrides_duplicate_last_write_wins_warning() -> None:
-    station = _make_station()
-    entries, warnings = station._build_partial_parameter_entries(
-        sample_excel_relative_path="x",
-        day_key="day2",
-        parameter_overrides=[
-            {"Key": "Example", "m": 0, "n": 0, "Value": "first"},
-            {"Key": "Example", "m": 0, "n": 0, "Value": "second"},
-        ],
-    )
-    example_entries = [e for e in entries if e["Key"] == "Example"]
-    assert len(example_entries) == 1
-    assert example_entries[0]["Value"] == "second"
-    assert any("重复" in w for w in warnings)
-
-
-def test_resolve_against_live_unique_match_and_failure() -> None:
-    station = _make_station()
-    resolved = station._resolve_parameter_entries_against_live_steps(
-        [{"Key": "SampleFile", "Value": "upload\\sample\\f.xlsx"}], FLATTENED_LIVE
-    )
-    assert resolved[0]["step"] == "39c78d4b-b5d3-f721-2001-9d52000084c3"
-    assert resolved[0]["m"] == 0 and resolved[0]["n"] == 0
-    # 没有 protocol 在 m/n=0/0 处 → 0 匹配
-    with pytest.raises(Exception) as exc:
-        station._resolve_parameter_entries_against_live_steps(
-            [{"Key": "protocol", "m": 0, "n": 0, "Value": "v"}], FLATTENED_LIVE
-        )
-    assert "0 条" in str(exc.value)
-
-
-def test_group_resolved_entries_uses_lowercase_keys() -> None:
-    station = _make_station()
-    grouped = station._group_resolved_entries_to_param_values([
-        {"step": "39c78d4b-b5d3-f721-2001-9d52000084c3", "Key": "SampleFile", "m": 0, "n": 0, "Value": "x"},
-    ])
-    step_entries = grouped["39c78d4b-b5d3-f721-2001-9d52000084c3"]
-    assert step_entries[0] == {"key": "SampleFile", "value": "x", "m": 0, "n": 0}
-
-
-def test_create_order_payload_shape() -> None:
-    station = _make_station()
-    payload = station._create_order_payload(
-        order_code="EXP260518-103000",
-        order_name="实验260518-103000",
-        sub_workflow_id="3a1d35f9-63ce-67d6-1784-9f6abcca4eda",
-        param_values={"39c78d4b-b5d3-f721-2001-9d52000084c3": [{"key": "SampleFile", "value": "x", "m": 0, "n": 0}]},
-        border_number=1,
-        extend_properties=None,
-    )
-    assert isinstance(payload, list) and len(payload) == 1
-    item = payload[0]
-    assert item["workFlowId"] == "3a1d35f9-63ce-67d6-1784-9f6abcca4eda"
-    assert item["paramValues"]
-    assert item["extendProperties"] == ""
-    assert item["borderNumber"] == 1
-
-
-def test_order_identity_format() -> None:
-    station = _make_station()
-    code, name = station._build_order_identity("day2")
-    assert code.startswith("EXP") and len(code) == 16  # EXP + YYMMDD-HHmmss
-    assert name.startswith("实验")
-    code2, name2 = station._build_order_identity("day2", "自定义")
-    assert name2 == "自定义"
-
-
-# ---------------------------------------------------------------------------
-# 5. Generic submit / day wrappers (含会抦住 BUG 1 的用例)
-# ---------------------------------------------------------------------------
-
-
-def _wire_submit_pipeline(station: Any) -> None:
-    station._resolve_workflow_binding_from_names = MagicMock(return_value={  # type: ignore[method-assign]
-        "workflow_name": "DAY2多肽定量",
-        "root_workflow_id": "3a1d35f0-9436-895b-2eda-039a5465275e",
-        "sub_workflow_id": "3a1d35f0-9f7e-c2c1-0bc0-8d94b81d90ca",
-        "sub_workflow_name": "DAY2多肽定量",
-        "raw": {},
-    })
-    station._resolve_workflow_binding = MagicMock(side_effect=lambda day_key: station._resolve_workflow_binding_from_names("DAY2多肽定量"))  # type: ignore[method-assign]
-    station._query_step_parameters = MagicMock(return_value={})  # type: ignore[method-assign]
-    station._flatten_step_parameters = MagicMock(return_value=FLATTENED_LIVE)  # type: ignore[method-assign]
-    station._create_order = MagicMock(return_value=json.dumps(CREATE_ALLOCATION))  # type: ignore[method-assign]
-
-
-def test_submit_experiment_generic_succeeds() -> None:
-    """plan §「Generic And Day 1 Submit」line 919-924；这条同时抦住 BUG 1（binding= 关键字）。"""
-    station = _make_station()
-    _wire_submit_pipeline(station)
-    result = station.submit_experiment(
-        {"workflow_name": "DAY2多肽定量", "sample_excel_pattern": ""},
-        {"parameter_overrides": []},
-        sample_excel_relative_path="upload/sample/f.xlsx",
-    )
-    assert result["success"] is True
-    assert result["order_id"] == ORDER_GUID
-    assert result["resultTable"]["tableName"] == "resultTable"
-
-
-def test_submit_experiment_rejects_day1_alias() -> None:
-    station = _make_station()
-    with pytest.raises(Exception):
-        station.submit_experiment(
-            {"workflow_name": "Day1线肽合成", "sample_excel_pattern": "x"},
-            {},
-            sample_excel_relative_path="upload/sample/f.xlsx",
-        )
-
-
-def test_submit_experiment_day2_calls_pipeline() -> None:
-    station = _make_station()
-    _wire_submit_pipeline(station)
-    result = station.submit_experiment_day2(
-        {"sample_excel_pattern": ""},
-        {"parameter_overrides": []},
-        sample_excel_relative_path="upload/sample/f.xlsx",
-    )
-    assert result["success"] is True
-    assert result["order_ids"] == [ORDER_GUID]
-    assert result["auto_register_materials"] is True
-    assert result["material_registration"]["status"] == "not_implemented"
-
-
-def test_day1_placeholder_does_not_call_create_order() -> None:
-    station = _make_station()
-    station._resolve_workflow_binding = MagicMock(return_value={  # type: ignore[method-assign]
-        "workflow_name": "Day1线肽合成",
-        "root_workflow_id": "rid",
-        "sub_workflow_id": "sid",
-        "sub_workflow_name": "Day1线肽合成",
-        "raw": {},
-    })
-    station._create_order = MagicMock(side_effect=AssertionError("Day1 不应触达 create_order"))  # type: ignore[method-assign]
-    out = station.submit_experiment_day1(
-        {"sample_excel_pattern": "", "cem_method_file_name": ""},
-        {},
-        sample_excel_relative_path="upload/sample/f.xlsx",
-        # 模拟人工确认框架注入的字段（这条会抦住 BUG 3）
-        timeout_seconds=3600,
-        assignee_user_ids=[],
-        materials_loaded=False,
-    )
-    assert out["status"] == "manual_confirm_placeholder"
-    assert out["cem_method_file_name"] == "5microdouble-20250911.MPM"
-    assert isinstance(out["partial_parameter_entries"], list)
-
-
-# ---------------------------------------------------------------------------
-# 6. Allocation map parsing + resultTable
-# ---------------------------------------------------------------------------
-
-
-def test_parse_allocation_map_extracts_order_id_and_groups() -> None:
-    station = _make_station()
-    parsed = station._parse_create_order_allocation_map(json.dumps(CREATE_ALLOCATION))
-    assert parsed["order_ids"] == [ORDER_GUID]
-    assert len(parsed["allocation_rows"]) == 3
-    assert set(parsed["materials_by_type"].keys()) == {"Consumables", "Sample", "Future"}
-
-
-def test_parse_allocation_map_handles_python_str_repr() -> None:
-    """RPC.create_order 返回的是 str(dict)，含单引号。"""
-    station = _make_station()
-    parsed = station._parse_create_order_allocation_map(str(CREATE_ALLOCATION))
-    assert parsed["order_ids"] == [ORDER_GUID]
-
-
-def test_parse_allocation_map_empty() -> None:
-    station = _make_station()
-    parsed = station._parse_create_order_allocation_map("{}")
-    assert parsed["allocation_rows"] == []
-    assert parsed["order_ids"] == []
-
-
-def test_build_result_table_order_and_columns() -> None:
-    station = _make_station()
-    parsed = station._parse_create_order_allocation_map(json.dumps(CREATE_ALLOCATION))
-    table = station._build_result_table(parsed["materials_by_type"])
-    assert table["tableName"] == "resultTable"
-    assert [c["key"] for c in table["columns"]] == ["whName", "locationCode", "materialName", "quantity"]
-    # 顺序：Sample → Consumables → Future（未知 mode 保留在末尾）
-    names = [row["materialName"] for row in table["data"]]
-    assert names == ["96孔板", "200μL枪头盒", "未知耗材"]
-    # locationShowName 优先 locationCode
-    assert table["data"][0]["locationCode"] == "A1-show"
-    assert table["data"][1]["locationCode"] == "1-01"
-
-
-def test_build_result_table_empty_returns_empty_data() -> None:
-    station = _make_station()
-    table = station._build_result_table({})
-    assert table["data"] == []
-    assert [c["key"] for c in table["columns"]] == ["whName", "locationCode", "materialName", "quantity"]
-
-
-def test_resolve_wh_name_handles_material_info_failure() -> None:
-    station = _make_station()
-    station.hardware_interface.material_info.side_effect = RuntimeError("HTTP 500")
-    cache: Dict[str, Dict[str, Any]] = {}
-    assert station._resolve_wh_name_by_material_id("mat-1", cache) == ""
-
-
-def test_submit_returns_warning_when_allocation_empty() -> None:
-    station = _make_station()
-    _wire_submit_pipeline(station)
-    station._create_order = MagicMock(return_value="{}")  # type: ignore[method-assign]
-    result = station.submit_experiment_day2(
-        {"sample_excel_pattern": ""},
-        {},
-        sample_excel_relative_path="upload/sample/f.xlsx",
-    )
-    assert "create_order_allocation_unavailable_for_result_table" in result["warnings"]
-
-
-# ---------------------------------------------------------------------------
-# 7. Reports + workflow records
-# ---------------------------------------------------------------------------
-
-
-def test_get_order_list_passes_json_string() -> None:
-    station = _make_station()
-    station.hardware_interface.order_query.return_value = {"items": [], "totalCount": 0}
-    station.get_order_list(filter_text="abc", page_count=10)
-    args, kwargs = station.hardware_interface.order_query.call_args
-    payload = json.loads(args[0])
-    assert payload["filter"] == "abc"
-    assert payload["pageCount"] == 10
-
-
-def test_get_order_report_calls_typed_rpc() -> None:
-    station = _make_station()
-    station.hardware_interface.order_report.return_value = {"id": ORDER_GUID, "name": "x", "preIntakes": [], "resultList": []}
-    out = station.get_order_report(ORDER_GUID)
-    station.hardware_interface.order_report.assert_called_once_with(ORDER_GUID)
-    assert out["success"] is True
-    assert out["summary"]["id"] == ORDER_GUID
-
-
-def test_get_aggregated_order_report_is_todo_placeholder() -> None:
-    station = _make_station()
-    out = station.get_aggregated_order_report(ORDER_GUID)
-    assert out["status"] == "not_implemented"
-
-
-def test_query_workflow_records_filters_unsaved_subworkflows() -> None:
-    station = _make_station()
-    station.hardware_interface.query_workflow.return_value = {
-        "items": [
-            {
-                "id": "rid",
-                "name": "Day3线肽环化",
-                "subWorkflows": [
-                    {"id": "saved-id", "name": "Day3线肽环化", "isSaved": True},
-                    {"id": "draft-id", "name": "Day3线肽环化-草稿", "isSaved": False},
-                ],
-            }
-        ]
-    }
-    records = station._query_workflow_records("Day3线肽环化")
-    assert [r["subworkflowId"] for r in records] == ["saved-id"]
-
-
-# ---------------------------------------------------------------------------
-# 8. Debug / fetch_workflow_list 守护
-# ---------------------------------------------------------------------------
-
-
-def test_module_fetch_workflow_list_is_debug_guarded() -> None:
-    module = _import_module()
-    assert module.DEBUG_CLI_ENABLED is False
-    with pytest.raises(AssertionError):
-        module.fetch_workflow_list(config={"api_host": "http://x", "api_key": "k"})
-
-
-def test_station_fetch_workflow_list_uses_rpc() -> None:
-    station = _make_station()
-    station.hardware_interface.query_workflow.return_value = {"items": [], "totalCount": 0}
-    station.fetch_workflow_list(filter_text="Day2")
-    args, _ = station.hardware_interface.query_workflow.call_args
-    payload = json.loads(args[0])
-    assert payload["filter"] == "Day2"
-    assert payload["includeDetail"] is True
-
-
-# ---------------------------------------------------------------------------
-# 9. start_experiment 装载闸门
-# ---------------------------------------------------------------------------
-
-
-def test_start_experiment_blocks_when_materials_not_loaded() -> None:
-    station = _make_station()
-    station.hardware_interface.scheduler_start.return_value = 1
-    with pytest.raises(RuntimeError):
-        station.start_experiment(
-            order_id=ORDER_GUID,
-            resultTable={"data": [{"materialName": "x"}]},
-            materials_loaded=False,
-        )
-
-
-def test_start_experiment_starts_when_table_empty() -> None:
-    station = _make_station()
-    station.hardware_interface.scheduler_start.return_value = 1
-    result = station.start_experiment(order_id=ORDER_GUID, resultTable={"data": []})
-    assert result["success"] is True
-    assert result["order_ids"] == [ORDER_GUID]
-
-
-# ---------------------------------------------------------------------------
-# 10. Reset
-# ---------------------------------------------------------------------------
-
-
-def test_reset_signature_drops_legacy_params_and_uses_literal() -> None:
-    """plan 调整：删除 dry_run/order_id/location_id；reset_operations 用 Literal 注解。"""
-    cls = getattr(_import_module(), CLASS_NAME)
-    sig = inspect.signature(cls.reset)
-    params = sig.parameters
-    for legacy in ("dry_run", "order_id", "location_id"):
-        assert legacy not in params, f"reset 不应再有 {legacy} 入参"
-    assert "reset_operations" in params
-    assert any(p.kind == inspect.Parameter.VAR_KEYWORD for p in params.values()), \
-        "reset 必须保留 **kwargs 以兜底 reset_order_id/reset_location_id"
-
-    annotation = params["reset_operations"].annotation
-    rendered = annotation if isinstance(annotation, str) else repr(annotation)
-    for op in ("scheduler_reset", "reset_order_status", "reset_location"):
-        assert op in rendered, f"reset_operations 的 Literal 必须包含 {op}"
-
-
-def test_reset_goal_default_contains_all_operations() -> None:
-    """像 sirna 一样，goal_default 默认勾选全部三个 reset 操作。"""
-    cls = getattr(_import_module(), CLASS_NAME)
-    meta = getattr(cls.reset, "_action_registry_meta", {})
-    goal_default = meta.get("goal_default") or {}
-    assert goal_default.get("reset_operations") == [
-        "scheduler_reset",
-        "reset_order_status",
-        "reset_location",
-    ]
-
-
-def test_reset_executes_typed_rpc_calls() -> None:
-    station = _make_station()
-    station.hardware_interface.scheduler_reset.return_value = 1
-    station.hardware_interface.reset_order_status.return_value = 1
-    station.hardware_interface.reset_location.return_value = 1
-    out = station.reset(
-        reset_operations=["scheduler_reset", "reset_order_status", "reset_location"],
-        reset_order_id=ORDER_GUID,
-        reset_location_id="loc-1",
-    )
-    station.hardware_interface.scheduler_reset.assert_called_once_with()
-    station.hardware_interface.reset_order_status.assert_called_once_with(ORDER_GUID)
-    station.hardware_interface.reset_location.assert_called_once_with("loc-1")
-    assert out["selected_operations"] == [
-        "scheduler_reset",
-        "reset_order_status",
-        "reset_location",
-    ]
-    assert len(out["executed_calls"]) == 3
-    assert out["skipped_operations"] == []
-
-
-def test_reset_skips_when_ids_missing() -> None:
-    """没有 order_id / location_id 时应该 skip 而不是抛错。"""
-    station = _make_station()
-    station.hardware_interface.scheduler_reset.return_value = 1
-    out = station.reset(
-        reset_operations=["scheduler_reset", "reset_order_status", "reset_location"],
-    )
-    station.hardware_interface.scheduler_reset.assert_called_once_with()
-    station.hardware_interface.reset_order_status.assert_not_called()
-    station.hardware_interface.reset_location.assert_not_called()
-    skipped_ops = {item["operation"] for item in out["skipped_operations"]}
-    assert skipped_ops == {"reset_order_status", "reset_location"}

unilabos/devices/workstation/bioyond_studio/station.py

@@ -7,7 +7,6 @@ Bioyond Workstation Implementation
 import time
 import traceback
 import threading
-from contextlib import contextmanager
 from datetime import datetime
 from typing import Dict, Any, List, Optional, Union
 import json
@@ -15,7 +14,6 @@ from pathlib import Path
 
 from unilabos.devices.workstation.workstation_base import WorkstationBase, ResourceSynchronizer
 from unilabos.devices.workstation.bioyond_studio.bioyond_rpc import BioyondV1RPC
-from unilabos.devices.workstation.bioyond_studio import debug_call_log
 from unilabos.registry.placeholder_type import ResourceSlot, DeviceSlot
 from unilabos.resources.warehouse import WareHouse
 from unilabos.utils.log import logger
@@ -176,8 +174,6 @@ class BioyondResourceSynchronizer(ResourceSynchronizer):
                 logger.warning("从Bioyond获取的物料数据为空")
                 return False
 
-            self._update_material_cache_from_stock(all_bioyond_data)
-
             # 转换为UniLab格式
             unilab_resources = resource_bioyond_to_plr(
                 all_bioyond_data,
@@ -191,29 +187,6 @@ class BioyondResourceSynchronizer(ResourceSynchronizer):
             logger.error(f"从Bioyond同步物料数据失败: {e}")
             return False
 
-    def _update_material_cache_from_stock(self, materials: List[Dict[str, Any]]) -> None:
-        """用本次库存查询结果同步 RPC 的 name -> material id 缓存。"""
-        material_cache = getattr(self.bioyond_api_client, "material_cache", None)
-        if not isinstance(material_cache, dict):
-            return
-
-        before_count = len(material_cache)
-        for material in materials:
-            material_name = material.get("name")
-            material_id = material.get("id")
-            if material_name and material_id:
-                material_cache[material_name] = material_id
-
-            for detail_material in material.get("detail", []) or []:
-                detail_name = detail_material.get("name")
-                detail_id = detail_material.get("detailMaterialId") or detail_material.get("id")
-                if detail_name and detail_id:
-                    material_cache[detail_name] = detail_id
-
-        logger.debug(
-            f"已用Bioyond库存同步物料缓存: {before_count} -> {len(material_cache)}"
-        )
-
     def sync_to_external(self, resource: Any) -> bool:
         """将本地物料数据变更同步到Bioyond系统"""
         try:
@@ -705,70 +678,6 @@ class BioyondWorkstation(WorkstationBase):
     集成Bioyond物料管理的工作站实现
     """
 
-    # 子类（如 sirna / peptide）覆写以指定默认 raw-call 日志目录。
-    # 路径相对仓库根；为 None 时若 debug_log=True 仍会写入临时位置。
-    _DEBUG_LOG_DEFAULT_DIR: Optional[str] = None
-
-    def _create_bioyond_rpc(self, config: Dict[str, Any]) -> BioyondV1RPC:
-        """创建 Bioyond RPC 客户端并应用调试包装。
-
-        所有创建 ``BioyondV1RPC`` 的路径（饿汉初始化、Sirna 延迟初始化、
-        以及未来的前端重新配置路径）都应通过该 helper，
-        以确保 debug_log 包装与命名/日志策略保持一致。
-        """
-        rpc = BioyondV1RPC(config)
-        debug_call_log.wrap_rpc_http(rpc)
-        return rpc
-
-    def _set_hardware_interface(self, rpc: BioyondV1RPC) -> BioyondV1RPC:
-        """将已构造的 RPC 客户端设置到 ``self.hardware_interface``，并应用调试包装。"""
-        debug_call_log.wrap_rpc_http(rpc)
-        self.hardware_interface = rpc
-        return rpc
-
-    def _debug_log_resolved_dir(self) -> Path:
-        """解析 ``debug_log_dir`` 为绝对路径。"""
-        configured = (getattr(self, "bioyond_config", {}) or {}).get("debug_log_dir")
-        default_dir = getattr(self, "_DEBUG_LOG_DEFAULT_DIR", None)
-        candidate = configured or default_dir or "bioyond_debug_records"
-        path = Path(candidate)
-        if not path.is_absolute():
-            repo_root = Path(__file__).resolve().parents[4]
-            path = repo_root / path
-        return path
-
-    def _ensure_debug_log_state(self) -> None:
-        """从 ``self.bioyond_config`` 派生 ``_debug_log_enabled`` / ``_debug_log_dir``。
-
-        每次进入 ``_debug_call_session`` 时都重新解析，以兼容前端在运行时
-        修改 ``bioyond_config['debug_log']`` 或目录的场景；同时也容忍
-        子类（如 Sirna 延迟初始化）在 ``__init__`` 早期未触发本方法。
-        """
-        cfg = getattr(self, "bioyond_config", {}) or {}
-        self._debug_log_enabled = bool(cfg.get("debug_log"))
-        self._debug_log_dir = self._debug_log_resolved_dir()
-
-    @contextmanager
-    def _debug_call_session(self, action_name: str):
-        """在 action 体外加一层 debug 会话上下文。
-
-        - ``debug_log`` 关闭时是空上下文，开销为 0。
-        - ``debug_log`` 开启时进入 :func:`debug_call_log.session`，所有
-          已被 ``wrap_rpc_http`` 包装过的 RPC 客户端都会捕获本次 action
-          产生的 HTTP 调用并写入 Markdown 文件。
-
-        子类（如 ``end_experiment``、``manual_unload`` 等）可以直接在
-        action 体里以 ``with self._debug_call_session("action_name"):`` 包裹。
-        """
-        cfg = getattr(self, "bioyond_config", {}) or {}
-        enabled = bool(cfg.get("debug_log"))
-        if not enabled:
-            yield None
-            return
-        out_dir = BioyondWorkstation._debug_log_resolved_dir(self)
-        with debug_call_log.session(action_name, out_dir) as ctx:
-            yield ctx
-
     def _publish_task_status(
         self,
         task_id: str,
@@ -953,7 +862,7 @@ class BioyondWorkstation(WorkstationBase):
             self.bioyond_config = {}
             print("警告: 未提供 bioyond_config，请确保在 JSON 配置文件中提供完整配置")
 
-        self.hardware_interface = self._create_bioyond_rpc(self.bioyond_config)
+        self.hardware_interface = BioyondV1RPC(self.bioyond_config)
 
     def resource_tree_add(self, resources: List[ResourcePLR]) -> None:
         """添加资源到资源树并更新ROS节点
@@ -1429,7 +1338,11 @@ class BioyondWorkstation(WorkstationBase):
             if self.hardware_interface:
                 self.hardware_interface.scheduler_reset()
 
-            # 重新同步资源，并用同一次库存查询结果更新物料缓存
+            # 刷新物料缓存
+            if self.hardware_interface:
+                self.hardware_interface.refresh_material_cache()
+
+            # 重新同步资源
             if self.resource_synchronizer:
                 self.resource_synchronizer.sync_from_external()
 

unilabos/resources/bioyond/__init__.py

@@ -1,9 +0,0 @@
-try:
-    from . import peptide_materials  # noqa: F401  ensure @resource classes are importable for PLR deserialize
-except Exception:  # pragma: no cover - 允许轻量环境导入非资源辅助函数
-    peptide_materials = None  # type: ignore[assignment]
-
-try:
-    from . import sirna_materials  # noqa: F401  ensure @resource classes are importable for PLR deserialize
-except Exception:  # pragma: no cover - 允许轻量环境导入非资源辅助函数
-    sirna_materials = None  # type: ignore[assignment]

unilabos/resources/bioyond/decks.py

@@ -1,8 +1,6 @@
 from os import name
-
 from pylabrobot.resources import Deck, Coordinate, Rotation
 
-from unilabos.registry.decorators import resource
 from unilabos.resources.bioyond.YB_warehouses import (
     bioyond_warehouse_1x4x4,
     bioyond_warehouse_1x4x4_right,  # 新增：右侧仓库 (A05～D08)
@@ -25,11 +23,6 @@ from unilabos.resources.bioyond.YB_warehouses import (
 from unilabos.resources.bioyond.warehouses import (
     bioyond_warehouse_tipbox_storage_left,   # 新增：Tip盒堆栈(左)
     bioyond_warehouse_tipbox_storage_right,  # 新增：Tip盒堆栈(右)
-    bioyond_warehouse_sirna_automation_stack,
-    bioyond_warehouse_sirna_centrifuge_balance_plate_stack,
-    bioyond_warehouse_sirna_g3_liquid_handler,
-    bioyond_warehouse_numeric_stack,  # 新增：数字编码堆栈 (用于多肽站)
-    bioyond_warehouse_live_grid,
 )
 
 
@@ -108,83 +101,6 @@ class BIOYOND_PolymerPreparationStation_Deck(Deck):
         for warehouse_name, warehouse in self.warehouses.items():
             self.assign_child_resource(warehouse, location=self.warehouse_locations[warehouse_name])
 
-@resource(
-    id="BIOYOND_SirnaStation_Deck",
-    category=["deck"],
-    description="BIOYOND 小核酸工作站 Deck",
-    icon="配液站.webp",
-)
-class BIOYOND_SirnaStation_Deck(Deck):
-    WAREHOUSE_BIOYOND_AXIS = {
-        "G3移液站": "xy_col_row",
-        "自动化堆栈": "xy_col_row",
-        "离心机配平板堆栈": "xy_col_row",
-    }
-    WAREHOUSE_BIOYOND_KEY_AXIS = {
-        "G3移液站": "col_row",
-        "自动化堆栈": "col_row",
-        "离心机配平板堆栈": "col_row",
-    }
-    # Bioyond warehouse UUID -> 本地仓库名称 映射。
-    # 留空时由配置（station config 的 ``warehouse_bioyond_ids``）注入。
-    # graph 节点也可在 deck.config.warehouse_bioyond_ids 覆盖。
-    WAREHOUSE_BIOYOND_IDS: dict = {}
-
-    def __init__(
-        self,
-        name: str = "SirnaStation_Deck",
-        size_x: float = 2700.0,
-        size_y: float = 1080.0,
-        size_z: float = 1500.0,
-        category: str = "deck",
-        setup: bool = False,
-        warehouse_bioyond_ids: dict | None = None,
-        **kwargs,
-    ) -> None:
-        super().__init__(name=name, size_x=size_x, size_y=size_y, size_z=size_z)
-        # 按需写入实例级覆盖；保留默认空 mapping，避免改动模型常量。
-        self.warehouse_bioyond_ids: dict = dict(self.WAREHOUSE_BIOYOND_IDS)
-        if warehouse_bioyond_ids:
-            self.warehouse_bioyond_ids.update(warehouse_bioyond_ids)
-        if setup:
-            self.setup()
-
-    @classmethod
-    def deserialize(cls, data: dict, allow_marshal: bool = False):
-        if data.get("children") and data.get("setup") is True:
-            data = data.copy()
-            data["setup"] = False
-        result = super().deserialize(data, allow_marshal=allow_marshal)
-        result._ensure_sirna_warehouse_metadata()
-        return result
-
-    def _ensure_sirna_warehouse_metadata(self) -> None:
-        for child in getattr(self, "children", []):
-            name = getattr(child, "name", "")
-            axis = self.WAREHOUSE_BIOYOND_AXIS.get(name)
-            if axis and not hasattr(child, "bioyond_axis"):
-                child.bioyond_axis = axis
-            key_axis = self.WAREHOUSE_BIOYOND_KEY_AXIS.get(name)
-            if key_axis and not hasattr(child, "bioyond_key_axis"):
-                child.bioyond_key_axis = key_axis
-
-    def setup(self) -> None:
-        # Sirna 读接口 /api/storage/location/locations-by-type 返回完整固定堆栈清单。
-        # LIMS 在库物料接口仍使用相同的 自动化堆栈 名称和数字库位编码。
-        self.warehouses = {
-            "G3移液站": bioyond_warehouse_sirna_g3_liquid_handler(),
-            "自动化堆栈": bioyond_warehouse_sirna_automation_stack(),
-            "离心机配平板堆栈": bioyond_warehouse_sirna_centrifuge_balance_plate_stack(),
-        }
-        self.warehouse_locations = {
-            "G3移液站": Coordinate(0.0, 0.0, 0.0),
-            "自动化堆栈": Coordinate(220.0, 0.0, 0.0),
-            "离心机配平板堆栈": Coordinate(1740.0, 0.0, 0.0),
-        }
-
-        for warehouse_name, warehouse in self.warehouses.items():
-            self.assign_child_resource(warehouse, location=self.warehouse_locations[warehouse_name])
-
 class BIOYOND_YB_Deck(Deck):
     def __init__(
         self,
@@ -234,207 +150,12 @@ class BIOYOND_YB_Deck(Deck):
         for warehouse_name, warehouse in self.warehouses.items():
             self.assign_child_resource(warehouse, location=self.warehouse_locations[warehouse_name])
 
-@resource(
-    id="BIOYOND_PeptideStation_Deck",
-    category=["deck"],
-    description="BIOYOND 多肽工作站 Deck",
-    icon="preparation_station.webp",
-)
-class BIOYOND_PeptideStation_Deck(Deck):
-    WAREHOUSE_BIOYOND_AXIS = dict.fromkeys(
-        [
-            "自动化堆栈",
-            "低温冰箱仓库",
-            "Tecan移液站库",
-            "G3移液站库",
-            "IDOT移液站库",
-            "G3缓冲库",
-            "盖板缓冲库",
-            "配平板缓冲库",
-            "IDOT缓冲库",
-            "固相合成板底座缓冲位",
-            "离心机库位",
-            "热封膜机位",
-        ],
-        "xy_col_row",
-    )
-    WAREHOUSE_BIOYOND_KEY_AXIS = dict.fromkeys(WAREHOUSE_BIOYOND_AXIS, "col_row")
-
-    def __init__(
-        self,
-        name: str = "PeptideStation_Deck",
-        size_x: float = 2700.0,
-        size_y: float = 2000.0,
-        size_z: float = 1500.0,
-        category: str = "deck",
-        setup: bool = False
-    ) -> None:
-        super().__init__(name=name, size_x=size_x, size_y=size_y, size_z=size_z)
-        if setup:
-            self.setup()
-
-    @classmethod
-    def deserialize(cls, data: dict, allow_marshal: bool = False):
-        if data.get("children") and data.get("setup") is True:
-            data = data.copy()
-            data["setup"] = False
-            # 已有序列化子资源，跳过 setup 避免重复创建
-            result = super(BIOYOND_PeptideStation_Deck, cls).deserialize(data, allow_marshal=allow_marshal)
-        else:
-            result = super(BIOYOND_PeptideStation_Deck, cls).deserialize(data, allow_marshal=allow_marshal)
-        result._ensure_peptide_warehouse_metadata()
-        return result
-
-    def _ensure_peptide_warehouse_metadata(self) -> None:
-        for child in getattr(self, "children", []):
-            name = getattr(child, "name", "")
-            axis = self.WAREHOUSE_BIOYOND_AXIS.get(name)
-            if axis and not hasattr(child, "bioyond_axis"):
-                child.bioyond_axis = axis
-            key_axis = self.WAREHOUSE_BIOYOND_KEY_AXIS.get(name)
-            if key_axis and not hasattr(child, "bioyond_key_axis"):
-                child.bioyond_key_axis = key_axis
-
-    def _frontend_y_flipped_coordinate(self, display_x: float, display_y: float, child) -> Coordinate:
-        """把期望显示坐标转换为兼容前端 y 轴翻转的存储坐标。"""
-        return Coordinate(display_x, self.get_size_y() - display_y - child.get_size_y(), 0.0)
-
-    def setup(self) -> None:
-        # 多肽工作站仓库配置
-        # 基于 2026-05-09 live API probe 发现的实际仓库拓扑 (12个仓库)
-        # 数据来源: Bioyond 现场仓库发现结果。
-        self.warehouses = {
-            # 主自动化堆栈 - live API: code 10-17 -> x=17, y=10，显示为 17 行×10 列
-            "自动化堆栈": bioyond_warehouse_numeric_stack(
-                "自动化堆栈",
-                rows=17,
-                columns=10,
-                bioyond_axis="xy_col_row",
-                bioyond_key_axis="col_row",
-                frontend_y_flip=True,
-            ),
-
-            # 低温存储
-            "低温冰箱仓库": bioyond_warehouse_live_grid(
-                "低温冰箱仓库",
-                rows=3,
-                columns=2,
-                slot_keys=["1", "2", "3", "4", "5", "6"],
-                bioyond_key_axis="col_row",
-                frontend_y_flip=True,
-            ),
-
-            # 移液站库位
-            "Tecan移液站库": bioyond_warehouse_live_grid(
-                "Tecan移液站库",
-                rows=18,
-                columns=1,
-                slot_keys=[str(index) for index in range(1, 19)],
-                bioyond_key_axis="col_row",
-                frontend_y_flip=True,
-            ),
-            "G3移液站库": bioyond_warehouse_live_grid(
-                "G3移液站库",
-                rows=18,
-                columns=1,
-                slot_keys=["1", "2", "3", "4", "垃圾桶", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18"],
-                bioyond_key_axis="col_row",
-                frontend_y_flip=True,
-            ),
-            "IDOT移液站库": bioyond_warehouse_live_grid(
-                "IDOT移液站库",
-                rows=12,
-                columns=1,
-                slot_keys=[f"0009-{index:04d}" for index in range(1, 13)],
-                bioyond_key_axis="col_row",
-                frontend_y_flip=True,
-            ),
-
-            # 缓冲库位
-            "G3缓冲库": bioyond_warehouse_live_grid(
-                "G3缓冲库",
-                rows=5,
-                columns=1,
-                slot_keys=[str(index) for index in range(1, 6)],
-                bioyond_key_axis="col_row",
-                frontend_y_flip=True,
-            ),
-            "盖板缓冲库": bioyond_warehouse_live_grid(
-                "盖板缓冲库",
-                rows=7,
-                columns=1,
-                slot_keys=[str(index) for index in range(1, 8)],
-                bioyond_key_axis="col_row",
-                frontend_y_flip=True,
-            ),
-            "配平板缓冲库": bioyond_warehouse_live_grid(
-                "配平板缓冲库",
-                rows=3,
-                columns=1,
-                slot_keys=[str(index) for index in range(1, 4)],
-                bioyond_key_axis="col_row",
-                frontend_y_flip=True,
-            ),
-            "IDOT缓冲库": bioyond_warehouse_live_grid(
-                "IDOT缓冲库",
-                rows=2,
-                columns=1,
-                slot_keys=["1", "1"],
-                bioyond_key_axis="col_row",
-                frontend_y_flip=True,
-            ),
-            "固相合成板底座缓冲位": bioyond_warehouse_live_grid(
-                "固相合成板底座缓冲位",
-                rows=4,
-                columns=1,
-                slot_keys=[f"0015-{index:04d}" for index in range(1, 5)],
-                bioyond_key_axis="col_row",
-                frontend_y_flip=True,
-            ),
-
-            # 设备库位
-            "离心机库位": bioyond_warehouse_live_grid(
-                "离心机库位",
-                rows=4,
-                columns=1,
-                slot_keys=[f"0017-{index:04d}" for index in range(1, 5)],
-                bioyond_key_axis="col_row",
-                frontend_y_flip=True,
-            ),
-            "热封膜机位": bioyond_warehouse_live_grid(
-                "热封膜机位",
-                rows=2,
-                columns=1,
-                slot_keys=[f"0016-{index:04d}" for index in range(1, 3)],
-                bioyond_key_axis="col_row",
-                frontend_y_flip=True,
-            ),
-        }
-
-        # 仓库显示布局：紧凑排列；存储 y 坐标按前端兼容翻转预先反向。
-        display_layout = {
-            "自动化堆栈": (0.0, 0.0),
-            "Tecan移液站库": (1520.0, 0.0),
-            "G3移液站库": (1710.0, 0.0),
-            "IDOT移液站库": (1900.0, 0.0),
-            "G3缓冲库": (2090.0, 0.0),
-            "盖板缓冲库": (2090.0, 580.0),
-            "低温冰箱仓库": (2280.0, 0.0),
-            "配平板缓冲库": (2280.0, 370.0),
-            "IDOT缓冲库": (2470.0, 370.0),
-            "固相合成板底座缓冲位": (2280.0, 740.0),
-            "离心机库位": (2470.0, 740.0),
-            "热封膜机位": (2280.0, 1210.0),
-        }
-        self.warehouse_locations = {
-            name: self._frontend_y_flipped_coordinate(x, y, self.warehouses[name])
-            for name, (x, y) in display_layout.items()
-        }
-
-        for warehouse_name, warehouse in self.warehouses.items():
-            self.assign_child_resource(warehouse, location=self.warehouse_locations[warehouse_name])
-
 def YB_Deck(name: str) -> Deck:
     by=BIOYOND_YB_Deck(name=name)
     by.setup()
     return by
+
+
+
+
+

unilabos/resources/bioyond/peptide_materials.py

@@ -1,247 +0,0 @@
-"""Peptide Station Material Resource Definitions."""
-
-from __future__ import annotations
-
-from collections import OrderedDict
-
-try:
-    from pylabrobot.resources import Container, Plate, TipRack
-except Exception:  # pragma: no cover - 允许无 pylabrobot 的轻量动作测试导入
-    class _FallbackResource:
-        def __init__(self, *args, **kwargs):
-            self.args = args
-            self.kwargs = kwargs
-
-    class Container(_FallbackResource):  # type: ignore[no-redef]
-        pass
-
-    class Plate(_FallbackResource):  # type: ignore[no-redef]
-        pass
-
-    class TipRack(_FallbackResource):  # type: ignore[no-redef]
-        pass
-
-try:
-    from unilabos.registry.decorators import resource
-except Exception:  # pragma: no cover - 允许无完整 registry 依赖时导入常量
-    def resource(*args, **kwargs):
-        def decorator(cls):
-            return cls
-
-        return decorator
-
-
-def _ensure_itemized_ordering(kwargs: dict) -> None:
-    if kwargs.get("ordering") is None and kwargs.get("ordered_items") is None:
-        kwargs["ordering"] = OrderedDict()
-
-
-class _PeptideTipRack(TipRack):
-    def __init__(self, *args, **kwargs):
-        kwargs.setdefault("size_x", 127.76)
-        kwargs.setdefault("size_y", 85.48)
-        kwargs.setdefault("size_z", 64.0)
-        kwargs.setdefault("with_tips", True)
-        _ensure_itemized_ordering(kwargs)
-        super().__init__(*args, **kwargs)
-
-
-class _PeptidePlate(Plate):
-    def __init__(self, *args, **kwargs):
-        kwargs.setdefault("size_x", 127.76)
-        kwargs.setdefault("size_y", 85.48)
-        kwargs.setdefault("size_z", 14.35)
-        kwargs.setdefault("plate_type", "skirted")
-        _ensure_itemized_ordering(kwargs)
-        super().__init__(*args, **kwargs)
-
-
-@resource(
-    id="bioyond_peptide_1000ul_tip_rack",
-    category=["labware", "tip_rack"],
-    description="1000uL tip rack for Bioyond peptide station",
-)
-class BioyondPeptide_1000ul_TipRack(_PeptideTipRack):
-    def __init__(self, *args, **kwargs):
-        kwargs.setdefault("model", "bioyond_peptide_1000ul_tip_rack")
-        super().__init__(*args, **kwargs)
-
-
-@resource(
-    id="bioyond_peptide_200ul_tip_rack",
-    category=["labware", "tip_rack"],
-    description="200uL tip rack for Bioyond peptide station",
-)
-class BioyondPeptide_200ul_TipRack(_PeptideTipRack):
-    def __init__(self, *args, **kwargs):
-        kwargs.setdefault("model", "bioyond_peptide_200ul_tip_rack")
-        super().__init__(*args, **kwargs)
-
-
-@resource(
-    id="bioyond_peptide_50ul_tip_rack",
-    category=["labware", "tip_rack"],
-    description="50uL tip rack for Bioyond peptide station",
-)
-class BioyondPeptide_50ul_TipRack(_PeptideTipRack):
-    def __init__(self, *args, **kwargs):
-        kwargs.setdefault("model", "bioyond_peptide_50ul_tip_rack")
-        super().__init__(*args, **kwargs)
-
-
-@resource(
-    id="bioyond_peptide_96_well_deep_well_plate",
-    category=["labware", "plate"],
-    description="96 well deep well plate for Bioyond peptide station",
-)
-class BioyondPeptide_96WellDeepWellPlate(_PeptidePlate):
-    def __init__(self, *args, **kwargs):
-        kwargs.setdefault("model", "bioyond_peptide_96_well_deep_well_plate")
-        kwargs.setdefault("size_z", 44.0)
-        super().__init__(*args, **kwargs)
-
-
-@resource(
-    id="bioyond_peptide_96_well_synthesis_plate",
-    category=["labware", "plate"],
-    description="96 well solid-phase synthesis plate for Bioyond peptide station",
-)
-class BioyondPeptide_96WellSynthesisPlate(_PeptidePlate):
-    def __init__(self, *args, **kwargs):
-        kwargs.setdefault("model", "bioyond_peptide_96_well_synthesis_plate")
-        super().__init__(*args, **kwargs)
-
-
-@resource(
-    id="bioyond_peptide_96_well_synthesis_plate_base",
-    category=["labware", "adapter"],
-    description="96 well solid-phase synthesis plate base for Bioyond peptide station",
-)
-class BioyondPeptide_96WellSynthesisPlateBase(_PeptidePlate):
-    def __init__(self, *args, **kwargs):
-        kwargs.setdefault("model", "bioyond_peptide_96_well_synthesis_plate_base")
-        kwargs.setdefault("size_z", 20.0)
-        super().__init__(*args, **kwargs)
-
-
-@resource(
-    id="bioyond_peptide_96_well_balance_plate",
-    category=["labware", "plate"],
-    description="96 well balance plate for Bioyond peptide station",
-)
-class BioyondPeptide_96WellBalancePlate(_PeptidePlate):
-    def __init__(self, *args, **kwargs):
-        kwargs.setdefault("model", "bioyond_peptide_96_well_balance_plate")
-        super().__init__(*args, **kwargs)
-
-
-@resource(
-    id="bioyond_peptide_384_well_plate",
-    category=["labware", "plate"],
-    description="384 well plate for Bioyond peptide station",
-)
-class BioyondPeptide_384WellPlate(_PeptidePlate):
-    def __init__(self, *args, **kwargs):
-        kwargs.setdefault("model", "bioyond_peptide_384_well_plate")
-        super().__init__(*args, **kwargs)
-
-
-@resource(
-    id="bioyond_peptide_384_lcms_plate",
-    category=["labware", "plate"],
-    description="384 well LCMS plate for Bioyond peptide station",
-)
-class BioyondPeptide_384LCMSPlate(_PeptidePlate):
-    def __init__(self, *args, **kwargs):
-        kwargs.setdefault("model", "bioyond_peptide_384_lcms_plate")
-        super().__init__(*args, **kwargs)
-
-
-@resource(
-    id="bioyond_peptide_384_balance_plate",
-    category=["labware", "plate"],
-    description="384 well balance plate for Bioyond peptide station",
-)
-class BioyondPeptide_384BalancePlate(_PeptidePlate):
-    def __init__(self, *args, **kwargs):
-        kwargs.setdefault("model", "bioyond_peptide_384_balance_plate")
-        super().__init__(*args, **kwargs)
-
-
-@resource(
-    id="bioyond_peptide_cover_plate",
-    category=["labware", "cover"],
-    description="Cover plate for Bioyond peptide station",
-)
-class BioyondPeptide_CoverPlate(_PeptidePlate):
-    def __init__(self, *args, **kwargs):
-        kwargs.setdefault("model", "bioyond_peptide_cover_plate")
-        kwargs.setdefault("size_z", 8.0)
-        super().__init__(*args, **kwargs)
-
-
-@resource(
-    id="bioyond_peptide_sealing_base",
-    category=["labware", "adapter"],
-    description="Sealing base for Bioyond peptide station",
-)
-class BioyondPeptide_SealingBase(_PeptidePlate):
-    def __init__(self, *args, **kwargs):
-        kwargs.setdefault("model", "bioyond_peptide_sealing_base")
-        kwargs.setdefault("size_z", 20.0)
-        super().__init__(*args, **kwargs)
-
-
-@resource(
-    id="bioyond_peptide_reagent_trough",
-    category=["labware", "trough"],
-    description="Reagent trough for Bioyond peptide station",
-)
-class BioyondPeptide_ReagentTrough(Container):
-    def __init__(self, *args, **kwargs):
-        kwargs.setdefault("size_x", 127.76)
-        kwargs.setdefault("size_y", 85.48)
-        kwargs.setdefault("size_z", 44.0)
-        kwargs.setdefault("max_volume", 300000.0)
-        kwargs.setdefault("model", "bioyond_peptide_reagent_trough")
-        super().__init__(*args, **kwargs)
-
-
-DEFAULT_PEPTIDE_MATERIAL_TYPE_MAPPINGS = {
-    "bioyond_peptide_1000ul_tip_rack": ["1000μL枪头盒", "3a1890bb-736e-cfdd-3213-eb314e8a60f9"],
-    "bioyond_peptide_200ul_tip_rack": ["200μL枪头盒", "3a1890bb-36d1-964a-18bd-0bf0f2877a7b"],
-    "bioyond_peptide_50ul_tip_rack": ["50μL枪头盒", "3a1890bc-5fae-361c-cc09-e6f2f6dcd71d"],
-    "bioyond_peptide_96_well_deep_well_plate": ["96孔深孔板", "3a1890bc-1fa8-fe39-9faa-12279ed4569b"],
-    "bioyond_peptide_96_well_synthesis_plate": ["96孔固相合成板", "3a1871cb-99f3-f01d-23e2-08dbbd0045b5"],
-    "bioyond_peptide_96_well_synthesis_plate_base": ["96孔固相合成板底座", "3a1b997e-241b-64f0-80d1-47bca08799d1"],
-    "bioyond_peptide_96_well_balance_plate": ["96孔配平板", "3a187661-2378-1e20-fa5c-a27d49fdc15d"],
-    "bioyond_peptide_384_well_plate": ["384孔酶标板", "3a1890bf-2148-ed20-92bd-d85869947d9a"],
-    "bioyond_peptide_384_lcms_plate": ["384孔LCMS板", "3a1e6a8b-cb61-74da-a089-8e6f197f80f0"],
-    "bioyond_peptide_384_balance_plate": ["384孔配平板", "3a18be7e-47cc-888c-fc68-055753286826"],
-    "bioyond_peptide_cover_plate": ["防挥发盖板", "3a19d5a6-b0e2-b486-e5eb-bcabc632f4de"],
-    "bioyond_peptide_sealing_base": ["封膜底座", "3a1d1d7b-e33b-6975-165d-c56cba5ed345"],
-    "bioyond_peptide_reagent_trough": ["12道试剂槽", "3a18b431-ac58-ca2e-9680-2a4f5880ea45"],
-}
-
-
-MATERIAL_TYPE_CODE_TO_CLASS = {
-    "0001": BioyondPeptide_96WellSynthesisPlate,
-    "0002": BioyondPeptide_96WellBalancePlate,
-    "0008": BioyondPeptide_200ul_TipRack,
-    "0009": BioyondPeptide_1000ul_TipRack,
-    "0011": BioyondPeptide_96WellDeepWellPlate,
-    "0012": BioyondPeptide_50ul_TipRack,
-    "0016": BioyondPeptide_384WellPlate,
-    "0018": BioyondPeptide_384WellPlate,
-    "0024": BioyondPeptide_ReagentTrough,
-    "0026": BioyondPeptide_384BalancePlate,
-    "0035": BioyondPeptide_CoverPlate,
-    "0039": BioyondPeptide_96WellSynthesisPlateBase,
-    "0041": BioyondPeptide_SealingBase,
-    "0049": BioyondPeptide_384LCMSPlate,
-}
-
-
-def get_material_class_by_type_code(type_code: str):
-    """Return a peptide material class by Bioyond material type code."""
-    return MATERIAL_TYPE_CODE_TO_CLASS.get(type_code)

unilabos/resources/bioyond/warehouses.py

@@ -1,192 +1,5 @@
-from pylabrobot.resources import Coordinate
-from pylabrobot.resources.carrier import ResourceHolder, create_homogeneous_resources
-
 from unilabos.resources.warehouse import WareHouse, warehouse_factory
 
-
-class BioyondWareHouse(WareHouse):
-    """Bioyond 仓库，额外保存服务端 x/y 坐标和库位标签语义。"""
-
-    def __init__(self, *args, bioyond_axis: str = "xy_row_col", bioyond_key_axis: str = "row_col", **kwargs):
-        super().__init__(*args, **kwargs)
-        self.bioyond_axis = bioyond_axis
-        self.bioyond_key_axis = bioyond_key_axis
-
-    def serialize(self) -> dict:
-        data = super().serialize()
-        data["bioyond_axis"] = self.bioyond_axis
-        data["bioyond_key_axis"] = self.bioyond_key_axis
-        return data
-
-
-def bioyond_warehouse_numeric_stack(
-    name: str,
-    rows: int = 10,
-    columns: int = 17,
-    bioyond_axis: str = "xy_row_col",
-    bioyond_key_axis: str = "row_col",
-    frontend_y_flip: bool = False,
-) -> WareHouse:
-    """创建 Bioyond 数字库位堆栈，库位名使用服务端返回的 行-列 格式。
-
-    bioyond_axis: 仓库级别的 Bioyond 坐标轴约定，供 graphio 的坐标映射使用。
-        - "xy_row_col" (default): Bioyond x→row, y→col (reaction/peptide 历史约定).
-        - "xy_col_row": Bioyond x→col, y→row (Sirna live API 实测约定).
-    bioyond_key_axis: 库位标签生成约定。
-        - "row_col" (default): 视觉行列和标签行列一致，例如 10 行 x 17 列 → 1-1..10-17。
-        - "col_row": 视觉行列转置，但标签仍保持 Bioyond row-col，例如
-          17 行 x 10 列 → 1-1..10-17。
-    未设置时 graphio 回退到默认 "xy_row_col"，其他调用方保持原行为。
-    """
-    num_items_x = columns
-    num_items_y = rows
-    num_items_z = 1
-    dx = 10.0
-    dy = 10.0
-    dz = 10.0
-    item_dx = 147.0
-    item_dy = 106.0
-    item_dz = 130.0
-    resource_size_x = 127.0
-    resource_size_y = 86.0
-    resource_size_z = 25.0
-    size_y = dy + item_dy * num_items_y
-    locations = []
-    for row in range(num_items_y):
-        display_y = dy + row * item_dy
-        y = size_y - display_y - resource_size_y if frontend_y_flip else display_y
-        for col in range(num_items_x):
-            locations.append(Coordinate(dx + col * item_dx, y, dz))
-    holders = create_homogeneous_resources(
-        klass=ResourceHolder,
-        locations=locations,
-        resource_size_x=resource_size_x,
-        resource_size_y=resource_size_y,
-        resource_size_z=resource_size_z,
-        name_prefix=name,
-    )
-    if bioyond_key_axis == "row_col":
-        keys = [
-            f"{row + 1}-{col + 1}"
-            for row in range(num_items_y)
-            for col in range(num_items_x)
-        ]
-    elif bioyond_key_axis == "col_row":
-        keys = [
-            f"{col + 1}-{row + 1}"
-            for row in range(num_items_y)
-            for col in range(num_items_x)
-        ]
-    else:
-        raise ValueError(f"未知 Bioyond 库位标签约定: {bioyond_key_axis!r}")
-    warehouse = BioyondWareHouse(
-        name=name,
-        size_x=dx + item_dx * num_items_x,
-        size_y=size_y,
-        size_z=dz + item_dz * num_items_z,
-        num_items_x=num_items_x,
-        num_items_y=num_items_y,
-        num_items_z=num_items_z,
-        ordering_layout="row-major",
-        sites={key: holder for key, holder in zip(keys, holders.values())},
-        category="warehouse",
-        bioyond_axis=bioyond_axis,
-        bioyond_key_axis=bioyond_key_axis,
-    )
-    return warehouse
-
-
-def bioyond_warehouse_live_grid(
-    name: str,
-    rows: int,
-    columns: int,
-    slot_keys: list[str] | None = None,
-    bioyond_axis: str = "xy_col_row",
-    bioyond_key_axis: str = "row_col",
-    frontend_y_flip: bool = False,
-) -> WareHouse:
-    """创建 Bioyond 实测库位网格，按服务端 code 保存位点标签。
-
-    默认用于 Peptide live API 返回的坐标：x 是视觉列，y 是视觉行。
-    当服务端 code 重复时，为保持 PLR ordering 唯一性，会给后续重复项追加 ``#N``。
-    """
-    num_items_x = columns
-    num_items_y = rows
-    num_items_z = 1
-    dx = 10.0
-    dy = 10.0
-    dz = 10.0
-    item_dx = 147.0
-    item_dy = 106.0
-    item_dz = 130.0
-    resource_size_x = 127.0
-    resource_size_y = 86.0
-    resource_size_z = 25.0
-    size_y = dy + item_dy * num_items_y
-    locations = []
-    for row in range(num_items_y):
-        display_y = dy + row * item_dy
-        y = size_y - display_y - resource_size_y if frontend_y_flip else display_y
-        for col in range(num_items_x):
-            locations.append(Coordinate(dx + col * item_dx, y, dz))
-    holders = create_homogeneous_resources(
-        klass=ResourceHolder,
-        locations=locations,
-        resource_size_x=resource_size_x,
-        resource_size_y=resource_size_y,
-        resource_size_z=resource_size_z,
-        name_prefix=name,
-    )
-    keys = slot_keys or [str(index + 1) for index in range(num_items_x * num_items_y)]
-    if len(keys) != len(holders):
-        raise ValueError(f"{name} 库位数量不匹配: keys={len(keys)}, holders={len(holders)}")
-
-    seen: dict[str, int] = {}
-    unique_keys: list[str] = []
-    for key in keys:
-        count = seen.get(key, 0) + 1
-        seen[key] = count
-        unique_keys.append(key if count == 1 else f"{key}#{count}")
-
-    return BioyondWareHouse(
-        name=name,
-        size_x=dx + item_dx * num_items_x,
-        size_y=size_y,
-        size_z=dz + item_dz * num_items_z,
-        num_items_x=num_items_x,
-        num_items_y=num_items_y,
-        num_items_z=num_items_z,
-        ordering_layout="row-major",
-        sites={key: holder for key, holder in zip(unique_keys, holders.values())},
-        category="warehouse",
-        bioyond_axis=bioyond_axis,
-        bioyond_key_axis=bioyond_key_axis,
-    )
-
-
-# ================ 小核酸工作站相关堆栈 ================
-
-def bioyond_warehouse_sirna_g3_liquid_handler(name: str = "G3移液站") -> WareHouse:
-    """创建小核酸 G3 移液站库位堆栈：显示为 14 行 x 1 列，标签保持 1-1..1-14。"""
-    return bioyond_warehouse_numeric_stack(
-        name, rows=14, columns=1, bioyond_axis="xy_col_row", bioyond_key_axis="col_row"
-    )
-
-
-def bioyond_warehouse_sirna_automation_stack(name: str = "自动化堆栈") -> WareHouse:
-    """创建小核酸自动化堆栈：显示为 17 行 x 10 列，标签保持 1-1..10-17。"""
-    return bioyond_warehouse_numeric_stack(
-        name, rows=17, columns=10, bioyond_axis="xy_col_row", bioyond_key_axis="col_row"
-    )
-
-
-def bioyond_warehouse_sirna_centrifuge_balance_plate_stack(name: str = "离心机配平板堆栈") -> WareHouse:
-    """创建小核酸离心机配平板堆栈：显示为 1 行 x 2 列，标签保持 1-1、2-1。"""
-    return bioyond_warehouse_numeric_stack(
-        name, rows=1, columns=2, bioyond_axis="xy_col_row", bioyond_key_axis="col_row"
-    )
-
-
 # ================ 反应站相关堆栈 ================
 
 def bioyond_warehouse_1x4x4(name: str) -> WareHouse:

unilabos/resources/graphio.py

@@ -42,7 +42,7 @@ def canonicalize_nodes_data(
     Returns:
         ResourceTreeSet: 标准化后的资源树集合
     """
-    print_status(f"{len(nodes)} Resources loaded", "info")
+    print_status(f"{len(nodes)} Resources loaded:", "info")
 
     # 第一步：基本预处理（处理graphml的label字段）
     outer_host_node_id = None
@@ -736,7 +736,7 @@ def resource_bioyond_to_plr(bioyond_materials: list[dict], type_mapping: Dict[st
             logger.warning(f"物料 {unique_name} 不是有效的 ResourcePLR 实例，类型: {type(plr_material)}")
             continue
 
-        plr_material.code = material.get("barCode") or material.get("code") or ""
+        plr_material.code = material.get("code", "") and material.get("barCode", "") or ""
         plr_material.unilabos_uuid = str(uuid.uuid4())
 
         # ⭐ 保存 Bioyond 原始信息到 unilabos_extra（用于出库时查询）
@@ -864,22 +864,11 @@ def resource_bioyond_to_plr(bioyond_materials: list[dict], type_mapping: Dict[st
                     warehouse = deck.warehouses[wh_name]
                     logger.debug(f"[Warehouse匹配] 找到warehouse: {wh_name} (容量: {warehouse.capacity}, 行×列: {warehouse.num_items_x}×{warehouse.num_items_y})")
 
-                    # Bioyond坐标映射:
-                    # - 历史 row_col 仓库中 x/y 直接按行/列参与索引。
-                    # - Sirna 的库位标签为 col-row，stock-material 返回 x=标签第二段、y=标签第一段。
-                    #   因此 x=13,y=4 应落到 key=4-13，而不是交换后落到 3-5。
-                    x = loc.get("x", 1)
-                    y = loc.get("y", 1)
+                    # Bioyond坐标映射 (重要！): x→行(1=A,2=B...), y→列(1=01,2=02...), z→层(通常=1)
+                    x = loc.get("x", 1)  # 行号 (1-based: 1=A, 2=B, 3=C, 4=D)
+                    y = loc.get("y", 1)  # 列号 (1-based: 1=01, 2=02, 3=03...)
                     z = loc.get("z", 1)  # 层号 (1-based, 通常为1)
 
-                    # 仓库级别的轴约定覆盖。
-                    # 对旧的 row-col 视觉标签，bioyond_axis="xy_col_row" 需要交换 x/y。
-                    # 对 Sirna 的 col-row 库位标签，原始 x/y 已能直接索引到 code 对应位置，不再交换。
-                    bioyond_axis = getattr(warehouse, "bioyond_axis", "xy_row_col")
-                    bioyond_key_axis = getattr(warehouse, "bioyond_key_axis", "row_col")
-                    if bioyond_axis == "xy_col_row" and bioyond_key_axis != "col_row":
-                        x, y = y, x
-
                     # 如果是右侧堆栈，需要调整列号 (5→1, 6→2, 7→3, 8→4)
                     if wh_name == "堆栈1右":
                         y = y - 4  # 将5-8映射到1-4
@@ -923,43 +912,10 @@ def resource_bioyond_to_plr(bioyond_materials: list[dict], type_mapping: Dict[st
                             logger.debug(f"列优先warehouse {wh_name}: x={x}(行),y={y}(列) → row={row_idx},col={col_idx} → idx={idx}")
 
                     if 0 <= idx < warehouse.capacity:
-                        slot_key = None
-                        ordering = getattr(warehouse, "_ordering", {})
-                        sites = getattr(warehouse, "sites", [])
-                        if isinstance(ordering, dict) and idx < len(sites):
-                            site_at_idx = sites[idx]
-                            slot_key = next(
-                                (key for key, site in ordering.items() if site is site_at_idx),
-                                None,
-                            )
-
-                        current_resource = warehouse[idx]
-                        if current_resource is None or isinstance(current_resource, (ResourceHolder, str)):
-                            if isinstance(current_resource, str):
-                                logger.warning(
-                                    f"⚠️ 物料 {unique_name} 覆盖 {wh_name}[{idx}]"
-                                    f"{f'({slot_key})' if slot_key else ''} 的旧占位 occupied_by={current_resource!r}"
-                                )
+                        if warehouse[idx] is None or isinstance(warehouse[idx], ResourceHolder):
                             # 物料尺寸已在放入warehouse前根据需要进行了交换
                             warehouse[idx] = plr_material
-                            logger.debug(
-                                f"✅ 物料 {unique_name} 放置到 {wh_name}[{idx}]"
-                                f"{f'({slot_key})' if slot_key else ''} "
-                                f"(Bioyond坐标: x={loc.get('x')}, y={loc.get('y')})"
-                            )
-                        else:
-                            parent = getattr(current_resource, "parent", None)
-                            current_repr = repr(current_resource)
-                            current_len = len(current_resource) if isinstance(current_resource, str) else None
-                            logger.warning(
-                                f"⚠️ 物料 {unique_name} 跳过放置到 {wh_name}[{idx}]"
-                                f"{f'({slot_key})' if slot_key else ''}：目标库位已有 "
-                                f"{type(current_resource).__name__}"
-                                f"(value={current_repr}, len={current_len})"
-                                f"(name={getattr(current_resource, 'name', None)}, "
-                                f"parent={getattr(parent, 'name', None)}, "
-                                f"uuid={getattr(current_resource, 'unilabos_uuid', None)})"
-                            )
+                            logger.debug(f"✅ 物料 {unique_name} 放置到 {wh_name}[{idx}] (Bioyond坐标: x={loc.get('x')}, y={loc.get('y')})")
                     else:
                         logger.warning(f"❌ 物料 {unique_name} 的索引 {idx} 超出仓库 {wh_name} 容量 {warehouse.capacity}")
                 else:

unilabos/resources/plr_additional_res_reg.py

@@ -18,7 +18,3 @@ def register():
     from unilabos.devices.liquid_handling.rviz_backend import UniLiquidHandlerRvizBackend
     from unilabos.devices.liquid_handling.laiyu.backend.laiyu_v_backend import UniLiquidHandlerLaiyuBackend
 
-    # noinspection PyUnresolvedReferences
-    from unilabos.resources.bioyond.decks import BIOYOND_SirnaStation_Deck
-    # noinspection PyUnresolvedReferences
-    from unilabos.resources.bioyond.decks import BIOYOND_PeptideStation_Deck

unilabos/utils/environment_check.py

@@ -47,7 +47,10 @@ def _has_uv() -> bool:
 
 def _install_command(installer: str, package: str, upgrade: bool, is_chinese: bool) -> List[str]:
     if installer == "uv":
-        cmd = ["uv", "pip", "install"]
+        # uv >= 0.5 默认要求虚拟环境，对 conda env 会报 "No virtual environment found"。
+        # 显式 --python sys.executable 让 uv 把当前解释器（conda/venv/system 都行）
+        # 视为目标环境，绕开 venv 检测。
+        cmd = ["uv", "pip", "install", "--python", sys.executable]
         if upgrade:
             cmd.append("--upgrade")
         cmd.append(package)
@@ -89,7 +92,11 @@ def _print_manual_git_install_hint(requirement: str) -> None:
         return
 
     repo_dir = _repo_dir_name(git_url)
-    install_cmd = "uv pip install -e ." if _has_uv() else f"{sys.executable} -m pip install -e ."
+    install_cmd = (
+        f'uv pip install --python "{sys.executable}" -e .'
+        if _has_uv()
+        else f"{sys.executable} -m pip install -e ."
+    )
     if _is_chinese_locale() and not _has_uv():
         install_cmd += " -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple"
 

unilabos/workflow/from_python_script.py

@@ -1,241 +0,0 @@
-import ast
-import json
-from typing import Dict, List, Any, Tuple, Optional
-
-from .common import WorkflowGraph, RegistryAdapter
-
-Json = Dict[str, Any]
-
-# ---------------- Converter ----------------
-
-class DeviceMethodConverter:
-    """
-    - 字段统一：resource_name（原 device_class）、template_name（原 action_key）
-    - params 单层；inputs 使用 'params.' 前缀
-    - SimpleGraph.add_workflow_node 负责变量连线与边
-    """
-    def __init__(self, device_registry: Optional[Dict[str, Any]] = None):
-        self.graph = WorkflowGraph()
-        self.variable_sources: Dict[str, Dict[str, Any]] = {}        # var -> {node_id, output_name}
-        self.instance_to_resource: Dict[str, Optional[str]] = {}     # 实例名 -> resource_name
-        self.node_id_counter: int = 0
-        self.registry = RegistryAdapter(device_registry or {})
-
-    # ---- helpers ----
-    def _new_node_id(self) -> int:
-        nid = self.node_id_counter
-        self.node_id_counter += 1
-        return nid
-
-    def _assign_targets(self, targets) -> List[str]:
-        names: List[str] = []
-        import ast
-        if isinstance(targets, ast.Tuple):
-            for elt in targets.elts:
-                if isinstance(elt, ast.Name):
-                    names.append(elt.id)
-        elif isinstance(targets, ast.Name):
-            names.append(targets.id)
-        return names
-
-    def _extract_device_instantiation(self, node) -> Optional[Tuple[str, str]]:
-        import ast
-        if not isinstance(node.value, ast.Call):
-            return None
-        callee = node.value.func
-        if isinstance(callee, ast.Name):
-            class_name = callee.id
-        elif isinstance(callee, ast.Attribute) and isinstance(callee.value, ast.Name):
-            class_name = callee.attr
-        else:
-            return None
-        if isinstance(node.targets[0], ast.Name):
-            instance = node.targets[0].id
-            return instance, class_name
-        return None
-
-    def _extract_call(self, call) -> Tuple[str, str, Dict[str, Any], str]:
-        import ast
-        owner_name, method_name, call_kind = "", "", "func"
-        if isinstance(call.func, ast.Attribute):
-            method_name = call.func.attr
-            if isinstance(call.func.value, ast.Name):
-                owner_name = call.func.value.id
-                call_kind = "instance" if owner_name in self.instance_to_resource else "class_or_module"
-            elif isinstance(call.func.value, ast.Attribute) and isinstance(call.func.value.value, ast.Name):
-                owner_name = call.func.value.attr
-                call_kind = "class_or_module"
-        elif isinstance(call.func, ast.Name):
-            method_name = call.func.id
-            call_kind = "func"
-
-        def pack(node):
-            if isinstance(node, ast.Name):
-                return {"type": "variable", "value": node.id}
-            if isinstance(node, ast.Constant):
-                return {"type": "constant", "value": node.value}
-            if isinstance(node, ast.Dict):
-                return {"type": "dict", "value": self._parse_dict(node)}
-            if isinstance(node, ast.List):
-                return {"type": "list", "value": self._parse_list(node)}
-            return {"type": "raw", "value": ast.unparse(node) if hasattr(ast, "unparse") else str(node)}
-
-        args: Dict[str, Any] = {}
-        pos: List[Any] = []
-        for a in call.args:
-            pos.append(pack(a))
-        for kw in call.keywords:
-            args[kw.arg] = pack(kw.value)
-        if pos:
-            args["_positional"] = pos
-        return owner_name, method_name, args, call_kind
-
-    def _parse_dict(self, node) -> Dict[str, Any]:
-        import ast
-        out: Dict[str, Any] = {}
-        for k, v in zip(node.keys, node.values):
-            if isinstance(k, ast.Constant):
-                key = str(k.value)
-                if isinstance(v, ast.Name):
-                    out[key] = f"var:{v.id}"
-                elif isinstance(v, ast.Constant):
-                    out[key] = v.value
-                elif isinstance(v, ast.Dict):
-                    out[key] = self._parse_dict(v)
-                elif isinstance(v, ast.List):
-                    out[key] = self._parse_list(v)
-        return out
-
-    def _parse_list(self, node) -> List[Any]:
-        import ast
-        out: List[Any] = []
-        for elt in node.elts:
-            if isinstance(elt, ast.Name):
-                out.append(f"var:{elt.id}")
-            elif isinstance(elt, ast.Constant):
-                out.append(elt.value)
-            elif isinstance(elt, ast.Dict):
-                out.append(self._parse_dict(elt))
-            elif isinstance(elt, ast.List):
-                out.append(self._parse_list(elt))
-        return out
-
-    def _normalize_var_tokens(self, x: Any) -> Any:
-        if isinstance(x, str) and x.startswith("var:"):
-            return {"__var__": x[4:]}
-        if isinstance(x, list):
-            return [self._normalize_var_tokens(i) for i in x]
-        if isinstance(x, dict):
-            return {k: self._normalize_var_tokens(v) for k, v in x.items()}
-        return x
-
-    def _make_params_payload(self, resource_name: Optional[str], template_name: str, call_args: Dict[str, Any]) -> Dict[str, Any]:
-        input_keys = self.registry.get_action_input_keys(resource_name, template_name) if resource_name else []
-        defaults = self.registry.get_action_goal_default(resource_name, template_name) if resource_name else {}
-        params: Dict[str, Any] = dict(defaults)
-
-        def unpack(p):
-            t, v = p.get("type"), p.get("value")
-            if t == "variable":
-                return {"__var__": v}
-            if t == "dict":
-                return self._normalize_var_tokens(v)
-            if t == "list":
-                return self._normalize_var_tokens(v)
-            return v
-
-        for k, p in call_args.items():
-            if k == "_positional":
-                continue
-            params[k] = unpack(p)
-
-        pos = call_args.get("_positional", [])
-        if pos:
-            if input_keys:
-                for i, p in enumerate(pos):
-                    if i >= len(input_keys):
-                        break
-                    name = input_keys[i]
-                    if name in params:
-                        continue
-                    params[name] = unpack(p)
-            else:
-                for i, p in enumerate(pos):
-                    params[f"arg_{i}"] = unpack(p)
-        return params
-
-    # ---- handlers ----
-    def _on_assign(self, stmt):
-        import ast
-        inst = self._extract_device_instantiation(stmt)
-        if inst:
-            instance, code_class = inst
-            resource_name = self.registry.resolve_resource_by_classname(code_class)
-            self.instance_to_resource[instance] = resource_name
-            return
-
-        if isinstance(stmt.value, ast.Call):
-            owner, method, call_args, kind = self._extract_call(stmt.value)
-            if kind == "instance":
-                device_key = owner
-                resource_name = self.instance_to_resource.get(owner)
-            else:
-                device_key = owner
-                resource_name = self.registry.resolve_resource_by_classname(owner)
-
-            module = self.registry.get_device_module(resource_name)
-            params = self._make_params_payload(resource_name, method, call_args)
-
-            nid = self._new_node_id()
-            self.graph.add_workflow_node(
-                nid,
-                device_key=device_key,
-                resource_name=resource_name,      # ✅
-                module=module,
-                template_name=method,             # ✅
-                params=params,
-                variable_sources=self.variable_sources,
-                add_ready_if_no_vars=True,
-                prev_node_id=(nid - 1) if nid > 0 else None,
-            )
-
-            out_vars = self._assign_targets(stmt.targets[0])
-            for var in out_vars:
-                self.variable_sources[var] = {"node_id": nid, "output_name": "result"}
-
-    def _on_expr(self, stmt):
-        import ast
-        if not isinstance(stmt.value, ast.Call):
-            return
-        owner, method, call_args, kind = self._extract_call(stmt.value)
-        if kind == "instance":
-            device_key = owner
-            resource_name = self.instance_to_resource.get(owner)
-        else:
-            device_key = owner
-            resource_name = self.registry.resolve_resource_by_classname(owner)
-
-        module = self.registry.get_device_module(resource_name)
-        params = self._make_params_payload(resource_name, method, call_args)
-
-        nid = self._new_node_id()
-        self.graph.add_workflow_node(
-            nid,
-            device_key=device_key,
-            resource_name=resource_name,      # ✅
-            module=module,
-            template_name=method,             # ✅
-            params=params,
-            variable_sources=self.variable_sources,
-            add_ready_if_no_vars=True,
-            prev_node_id=(nid - 1) if nid > 0 else None,
-        )
-
-    def convert(self, python_code: str):
-        tree = ast.parse(python_code)
-        for stmt in tree.body:
-            if isinstance(stmt, ast.Assign):
-                self._on_assign(stmt)
-            elif isinstance(stmt, ast.Expr):
-                self._on_expr(stmt)
-        return self

unilabos/workflow/from_xdl.py

@@ -1,131 +0,0 @@
-from typing import List, Any, Dict
-import xml.etree.ElementTree as ET
-
-
-def convert_to_type(val: str) -> Any:
-    """将字符串值转换为适当的数据类型"""
-    if val == "True":
-        return True
-    if val == "False":
-        return False
-    if val == "?":
-        return None
-    if val.endswith(" g"):
-        return float(val.split(" ")[0])
-    if val.endswith("mg"):
-        return float(val.split("mg")[0])
-    elif val.endswith("mmol"):
-        return float(val.split("mmol")[0]) / 1000
-    elif val.endswith("mol"):
-        return float(val.split("mol")[0])
-    elif val.endswith("ml"):
-        return float(val.split("ml")[0])
-    elif val.endswith("RPM"):
-        return float(val.split("RPM")[0])
-    elif val.endswith(" °C"):
-        return float(val.split(" ")[0])
-    elif val.endswith(" %"):
-        return float(val.split(" ")[0])
-    return val
-
-
-def flatten_xdl_procedure(procedure_elem: ET.Element) -> List[ET.Element]:
-    """展平嵌套的XDL程序结构"""
-    flattened_operations = []
-    TEMP_UNSUPPORTED_PROTOCOL = ["Purge", "Wait", "Stir", "ResetHandling"]
-
-    def extract_operations(element: ET.Element):
-        if element.tag not in ["Prep", "Reaction", "Workup", "Purification", "Procedure"]:
-            if element.tag not in TEMP_UNSUPPORTED_PROTOCOL:
-                flattened_operations.append(element)
-
-        for child in element:
-            extract_operations(child)
-
-    for child in procedure_elem:
-        extract_operations(child)
-
-    return flattened_operations
-
-
-def parse_xdl_content(xdl_content: str) -> tuple:
-    """解析XDL内容"""
-    try:
-        xdl_content_cleaned = "".join(c for c in xdl_content if c.isprintable())
-        root = ET.fromstring(xdl_content_cleaned)
-
-        synthesis_elem = root.find("Synthesis")
-        if synthesis_elem is None:
-            return None, None, None
-
-        # 解析硬件组件
-        hardware_elem = synthesis_elem.find("Hardware")
-        hardware = []
-        if hardware_elem is not None:
-            hardware = [{"id": c.get("id"), "type": c.get("type")} for c in hardware_elem.findall("Component")]
-
-        # 解析试剂
-        reagents_elem = synthesis_elem.find("Reagents")
-        reagents = []
-        if reagents_elem is not None:
-            reagents = [{"name": r.get("name"), "role": r.get("role", "")} for r in reagents_elem.findall("Reagent")]
-
-        # 解析程序
-        procedure_elem = synthesis_elem.find("Procedure")
-        if procedure_elem is None:
-            return None, None, None
-
-        flattened_operations = flatten_xdl_procedure(procedure_elem)
-        return hardware, reagents, flattened_operations
-
-    except ET.ParseError as e:
-        raise ValueError(f"Invalid XDL format: {e}")
-
-
-def convert_xdl_to_dict(xdl_content: str) -> Dict[str, Any]:
-    """
-    将XDL XML格式转换为标准的字典格式
-
-    Args:
-        xdl_content: XDL XML内容
-
-    Returns:
-        转换结果，包含步骤和器材信息
-    """
-    try:
-        hardware, reagents, flattened_operations = parse_xdl_content(xdl_content)
-        if hardware is None:
-            return {"error": "Failed to parse XDL content", "success": False}
-
-        # 将XDL元素转换为字典格式
-        steps_data = []
-        for elem in flattened_operations:
-            # 转换参数类型
-            parameters = {}
-            for key, val in elem.attrib.items():
-                converted_val = convert_to_type(val)
-                if converted_val is not None:
-                    parameters[key] = converted_val
-
-            step_dict = {
-                "operation": elem.tag,
-                "parameters": parameters,
-                "description": elem.get("purpose", f"Operation: {elem.tag}"),
-            }
-            steps_data.append(step_dict)
-
-        # 合并硬件和试剂为统一的labware_info格式
-        labware_data = []
-        labware_data.extend({"id": hw["id"], "type": "hardware", **hw} for hw in hardware)
-        labware_data.extend({"name": reagent["name"], "type": "reagent", **reagent} for reagent in reagents)
-
-        return {
-            "success": True,
-            "steps": steps_data,
-            "labware": labware_data,
-            "message": f"Successfully converted XDL to dict format. Found {len(steps_data)} steps and {len(labware_data)} labware items.",
-        }
-
-    except Exception as e:
-        error_msg = f"XDL conversion failed: {str(e)}"
-        return {"error": error_msg, "success": False}

unilabos_msgs/package.xml

@@ -2,7 +2,7 @@
 <?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <package format="3">
   <name>unilabos_msgs</name>
-  <version>0.11.1</version>
+  <version>0.11.2</version>
   <description>ROS2 Messages package for unilabos devices</description>
   <maintainer email="changjh@pku.edu.cn">Junhan Chang</maintainer>
   <maintainer email="18435084+Xuwznln@users.noreply.github.com">Xuwznln</maintainer>