reverts edge上传相反

This reverts commit ad1312cf26.

.conda/recipe.yaml

@@ -1,6 +1,6 @@
 package:
   name: unilabos
-  version: 0.10.14
+  version: 0.10.13
 
 source:
   path: ../unilabos
@@ -9,7 +9,7 @@ source:
 build:
   python:
     entry_points:
-    - unilab = unilabos.app.main:main
+     - unilab = unilabos.app.main:main
   script:
   - set PIP_NO_INDEX=
   - if: win
@@ -25,6 +25,7 @@ build:
     - cp $RECIPE_DIR/../setup.py $SRC_DIR
     - $PYTHON -m pip install $SRC_DIR
 
+
 requirements:
   host:
   - python ==3.11.11
@@ -86,6 +87,6 @@ requirements:
   - uni-lab::ros-humble-unilabos-msgs
 
 about:
-  repository: https://github.com/deepmodeling/Uni-Lab-OS
+  repository: https://github.com/dptech-corp/Uni-Lab-OS
   license: GPL-3.0-only
   description: "Uni-Lab-OS"

.cursorignore

@@ -1,26 +0,0 @@
-.conda
-# .github
-.idea
-# .vscode
-output
-pylabrobot_repo
-recipes
-scripts
-service
-temp
-# unilabos/test
-# unilabos/app/web
-unilabos/device_mesh
-unilabos_data
-unilabos_msgs
-unilabos.egg-info
-CONTRIBUTORS
-# LICENSE
-MANIFEST.in
-pyrightconfig.json
-# README.md
-# README_zh.md
-setup.py
-setup.cfg
-.gitattrubutes
-**/__pycache__

.gitignore

@@ -1,4 +1,3 @@
-cursor_docs/
 configs/
 temp/
 output/

NOTICE

@@ -1,17 +0,0 @@
-# Uni-Lab-OS Licensing Notice
-
-This project uses a dual licensing structure:
-
-## 1. Main Framework - GPL-3.0
-
-- unilabos/ (except unilabos/devices/)
-- docs/
-- tests/
-
-See [LICENSE](LICENSE) for details.
-
-## 2. Device Drivers - DP Technology Proprietary License
-
-- unilabos/devices/
-
-See [unilabos/devices/LICENSE](unilabos/devices/LICENSE) for details.

README.md

@@ -8,13 +8,17 @@
 
 **English** | [中文](README_zh.md)
 
-[![GitHub Stars](https://img.shields.io/github/stars/dptech-corp/Uni-Lab-OS.svg)](https://github.com/deepmodeling/Uni-Lab-OS/stargazers)
-[![GitHub Forks](https://img.shields.io/github/forks/dptech-corp/Uni-Lab-OS.svg)](https://github.com/deepmodeling/Uni-Lab-OS/network/members)
-[![GitHub Issues](https://img.shields.io/github/issues/dptech-corp/Uni-Lab-OS.svg)](https://github.com/deepmodeling/Uni-Lab-OS/issues)
-[![GitHub License](https://img.shields.io/github/license/dptech-corp/Uni-Lab-OS.svg)](https://github.com/deepmodeling/Uni-Lab-OS/blob/main/LICENSE)
+[![GitHub Stars](https://img.shields.io/github/stars/dptech-corp/Uni-Lab-OS.svg)](https://github.com/dptech-corp/Uni-Lab-OS/stargazers)
+[![GitHub Forks](https://img.shields.io/github/forks/dptech-corp/Uni-Lab-OS.svg)](https://github.com/dptech-corp/Uni-Lab-OS/network/members)
+[![GitHub Issues](https://img.shields.io/github/issues/dptech-corp/Uni-Lab-OS.svg)](https://github.com/dptech-corp/Uni-Lab-OS/issues)
+[![GitHub License](https://img.shields.io/github/license/dptech-corp/Uni-Lab-OS.svg)](https://github.com/dptech-corp/Uni-Lab-OS/blob/main/LICENSE)
 
 Uni-Lab-OS is a platform for laboratory automation, designed to connect and control various experimental equipment, enabling automation and standardization of experimental workflows.
 
+## 🏆 Competition
+
+Join the [Intelligent Organic Chemistry Synthesis Competition](https://bohrium.dp.tech/competitions/1451645258) to explore automated synthesis with Uni-Lab-OS!
+
 ## Key Features
 
 - Multi-device integration management
@@ -27,7 +31,7 @@ Uni-Lab-OS is a platform for laboratory automation, designed to connect and cont
 
 Detailed documentation can be found at:
 
-- [Online Documentation](https://deepmodeling.github.io/Uni-Lab-OS/)
+- [Online Documentation](https://xuwznln.github.io/Uni-Lab-OS-Doc/)
 
 ## Quick Start
 
@@ -44,7 +48,7 @@ mamba install -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
 
 ```bash
 # Clone the repository
-git clone https://github.com/deepmodeling/Uni-Lab-OS.git
+git clone https://github.com/dptech-corp/Uni-Lab-OS.git
 cd Uni-Lab-OS
 
 # Install Uni-Lab-OS
@@ -53,37 +57,15 @@ pip install .
 
 3. Start Uni-Lab System:
 
-Please refer to [Documentation - Boot Examples](https://deepmodeling.github.io/Uni-Lab-OS/boot_examples/index.html)
+Please refer to [Documentation - Boot Examples](https://xuwznln.github.io/Uni-Lab-OS-Doc/boot_examples/index.html)
 
 ## Message Format
 
-Uni-Lab-OS uses pre-built `unilabos_msgs` for system communication. You can find the built versions on the [GitHub Releases](https://github.com/deepmodeling/Uni-Lab-OS/releases) page.
-
-## Citation
-
-If you use Uni-Lab-OS in academic research, please cite:
-
-```bibtex
-@article{gao2025unilabos,
-    title = {UniLabOS: An AI-Native Operating System for Autonomous Laboratories},
-    doi = {10.48550/arXiv.2512.21766},
-    publisher = {arXiv},
-    author = {Gao, Jing and Chang, Junhan and Que, Haohui and Xiong, Yanfei and
-              Zhang, Shixiang and Qi, Xianwei and Liu, Zhen and Wang, Jun-Jie and
-              Ding, Qianjun and Li, Xinyu and Pan, Ziwei and Xie, Qiming and
-              Yan, Zhuang and Yan, Junchi and Zhang, Linfeng},
-    year = {2025}
-}
-```
+Uni-Lab-OS uses pre-built `unilabos_msgs` for system communication. You can find the built versions on the [GitHub Releases](https://github.com/dptech-corp/Uni-Lab-OS/releases) page.
 
 ## License
 
-This project uses a dual licensing structure:
-
-- **Main Framework**: GPL-3.0 - see [LICENSE](LICENSE)
-- **Device Drivers** (`unilabos/devices/`): DP Technology Proprietary License
-
-See [NOTICE](NOTICE) for complete licensing details.
+This project is licensed under GPL-3.0 - see the [LICENSE](LICENSE) file for details.
 
 ## Project Statistics
 
@@ -95,4 +77,4 @@ See [NOTICE](NOTICE) for complete licensing details.
 
 ## Contact Us
 
-- GitHub Issues: [https://github.com/deepmodeling/Uni-Lab-OS/issues](https://github.com/deepmodeling/Uni-Lab-OS/issues)
+- GitHub Issues: [https://github.com/dptech-corp/Uni-Lab-OS/issues](https://github.com/dptech-corp/Uni-Lab-OS/issues)

README_zh.md

@@ -8,13 +8,17 @@
 
 [English](README.md) | **中文**
 
-[![GitHub Stars](https://img.shields.io/github/stars/dptech-corp/Uni-Lab-OS.svg)](https://github.com/deepmodeling/Uni-Lab-OS/stargazers)
-[![GitHub Forks](https://img.shields.io/github/forks/dptech-corp/Uni-Lab-OS.svg)](https://github.com/deepmodeling/Uni-Lab-OS/network/members)
-[![GitHub Issues](https://img.shields.io/github/issues/dptech-corp/Uni-Lab-OS.svg)](https://github.com/deepmodeling/Uni-Lab-OS/issues)
-[![GitHub License](https://img.shields.io/github/license/dptech-corp/Uni-Lab-OS.svg)](https://github.com/deepmodeling/Uni-Lab-OS/blob/main/LICENSE)
+[![GitHub Stars](https://img.shields.io/github/stars/dptech-corp/Uni-Lab-OS.svg)](https://github.com/dptech-corp/Uni-Lab-OS/stargazers)
+[![GitHub Forks](https://img.shields.io/github/forks/dptech-corp/Uni-Lab-OS.svg)](https://github.com/dptech-corp/Uni-Lab-OS/network/members)
+[![GitHub Issues](https://img.shields.io/github/issues/dptech-corp/Uni-Lab-OS.svg)](https://github.com/dptech-corp/Uni-Lab-OS/issues)
+[![GitHub License](https://img.shields.io/github/license/dptech-corp/Uni-Lab-OS.svg)](https://github.com/dptech-corp/Uni-Lab-OS/blob/main/LICENSE)
 
 Uni-Lab-OS 是一个用于实验室自动化的综合平台，旨在连接和控制各种实验设备，实现实验流程的自动化和标准化。
 
+## 🏆 比赛
+
+欢迎参加[有机化学合成智能实验大赛](https://bohrium.dp.tech/competitions/1451645258)，使用 Uni-Lab-OS 探索自动化合成！
+
 ## 核心特点
 
 - 多设备集成管理
@@ -27,7 +31,7 @@ Uni-Lab-OS 是一个用于实验室自动化的综合平台，旨在连接和控
 
 详细文档可在以下位置找到:
 
-- [在线文档](https://deepmodeling.github.io/Uni-Lab-OS/)
+- [在线文档](https://xuwznln.github.io/Uni-Lab-OS-Doc/)
 
 ## 快速开始
 
@@ -46,7 +50,7 @@ mamba install -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
 
 ```bash
 # 克隆仓库
-git clone https://github.com/deepmodeling/Uni-Lab-OS.git
+git clone https://github.com/dptech-corp/Uni-Lab-OS.git
 cd Uni-Lab-OS
 
 # 安装 Uni-Lab-OS
@@ -55,37 +59,15 @@ pip install .
 
 3. 启动 Uni-Lab 系统:
 
-请见[文档-启动样例](https://deepmodeling.github.io/Uni-Lab-OS/boot_examples/index.html)
+请见[文档-启动样例](https://xuwznln.github.io/Uni-Lab-OS-Doc/boot_examples/index.html)
 
 ## 消息格式
 
-Uni-Lab-OS 使用预构建的 `unilabos_msgs` 进行系统通信。您可以在 [GitHub Releases](https://github.com/deepmodeling/Uni-Lab-OS/releases) 页面找到已构建的版本。
-
-## 引用
-
-如果您在学术研究中使用 Uni-Lab-OS，请引用：
-
-```bibtex
-@article{gao2025unilabos,
-    title = {UniLabOS: An AI-Native Operating System for Autonomous Laboratories},
-    doi = {10.48550/arXiv.2512.21766},
-    publisher = {arXiv},
-    author = {Gao, Jing and Chang, Junhan and Que, Haohui and Xiong, Yanfei and
-              Zhang, Shixiang and Qi, Xianwei and Liu, Zhen and Wang, Jun-Jie and
-              Ding, Qianjun and Li, Xinyu and Pan, Ziwei and Xie, Qiming and
-              Yan, Zhuang and Yan, Junchi and Zhang, Linfeng},
-    year = {2025}
-}
-```
+Uni-Lab-OS 使用预构建的 `unilabos_msgs` 进行系统通信。您可以在 [GitHub Releases](https://github.com/dptech-corp/Uni-Lab-OS/releases) 页面找到已构建的版本。
 
 ## 许可证
 
-本项目采用双许可证结构：
-
-- **主框架**：GPL-3.0 - 详见 [LICENSE](LICENSE)
-- **设备驱动** (`unilabos/devices/`)：深势科技专有许可证
-
-完整许可证说明请参阅 [NOTICE](NOTICE)。
+此项目采用 GPL-3.0 许可 - 详情请参阅 [LICENSE](LICENSE) 文件。
 
 ## 项目统计
 
@@ -97,4 +79,4 @@ Uni-Lab-OS 使用预构建的 `unilabos_msgs` 进行系统通信。您可以在
 
 ## 联系我们
 
-- GitHub Issues: [https://github.com/deepmodeling/Uni-Lab-OS/issues](https://github.com/deepmodeling/Uni-Lab-OS/issues)
+- GitHub Issues: [https://github.com/dptech-corp/Uni-Lab-OS/issues](https://github.com/dptech-corp/Uni-Lab-OS/issues)

docs/user_guide/best_practice.md

@@ -1807,7 +1807,7 @@ unilab --ak your_ak --sk your_sk -g graph.json \
 
 #### 14.5 社区支持
 
-- **GitHub Issues**：[https://github.com/deepmodeling/Uni-Lab-OS/issues](https://github.com/deepmodeling/Uni-Lab-OS/issues)
+- **GitHub Issues**：[https://github.com/dptech-corp/Uni-Lab-OS/issues](https://github.com/dptech-corp/Uni-Lab-OS/issues)
 - **官方网站**：[https://uni-lab.bohrium.com](https://uni-lab.bohrium.com)
 
 ---

docs/user_guide/graph_files.md

@@ -857,4 +857,4 @@ class ResourceDictPosition(BaseModel):
 - 在 Web 界面中使用模板创建
 - 参考示例文件：`test/experiments/` 目录
 - 查看 ResourceDict 源码了解完整定义
-- [GitHub 讨论区](https://github.com/deepmodeling/Uni-Lab-OS/discussions)
+- [GitHub 讨论区](https://github.com/dptech-corp/Uni-Lab-OS/discussions)

docs/user_guide/installation.md

@@ -37,7 +37,7 @@
 
 #### 第一步：下载预打包环境
 
-1. 访问 [GitHub Actions - Conda Pack Build](https://github.com/deepmodeling/Uni-Lab-OS/actions/workflows/conda-pack-build.yml)
+1. 访问 [GitHub Actions - Conda Pack Build](https://github.com/dptech-corp/Uni-Lab-OS/actions/workflows/conda-pack-build.yml)
 
 2. 选择最新的成功构建记录（绿色勾号 ✓）
 
@@ -189,13 +189,13 @@ conda activate unilab
 ### 第一步：克隆仓库
 
 ```bash
-git clone https://github.com/deepmodeling/Uni-Lab-OS.git
+git clone https://github.com/dptech-corp/Uni-Lab-OS.git
 cd Uni-Lab-OS
 ```
 
 如果您需要贡献代码，建议先 Fork 仓库：
 
-1. 访问 https://github.com/deepmodeling/Uni-Lab-OS
+1. 访问 https://github.com/dptech-corp/Uni-Lab-OS
 2. 点击右上角的 "Fork" 按钮
 3. Clone 您的 Fork 版本：
    ```bash
@@ -240,7 +240,7 @@ pip uninstall unilabos -y
 
 # 克隆 dev 分支（如果还未克隆）
 cd /path/to/your/workspace
-git clone -b dev https://github.com/deepmodeling/Uni-Lab-OS.git
+git clone -b dev https://github.com/dptech-corp/Uni-Lab-OS.git
 # 或者如果已经克隆，切换到 dev 分支
 cd Uni-Lab-OS
 git checkout dev
@@ -503,9 +503,9 @@ mamba update ros-humble-unilabos-msgs -c uni-lab -c robostack-staging -c conda-f
 ## 需要帮助？
 
 - **故障排查**: 查看更详细的故障排查信息
-- **GitHub Issues**: [报告问题](https://github.com/deepmodeling/Uni-Lab-OS/issues)
+- **GitHub Issues**: [报告问题](https://github.com/dptech-corp/Uni-Lab-OS/issues)
 - **开发者文档**: 查看开发者指南获取更多技术细节
-- **社区讨论**: [GitHub Discussions](https://github.com/deepmodeling/Uni-Lab-OS/discussions)
+- **社区讨论**: [GitHub Discussions](https://github.com/dptech-corp/Uni-Lab-OS/discussions)
 
 ---
 

recipes/msgs/recipe.yaml

@@ -1,6 +1,6 @@
 package:
   name: ros-humble-unilabos-msgs
-  version: 0.10.14
+  version: 0.10.13
 source:
   path: ../../unilabos_msgs
   target_directory: src
@@ -17,7 +17,7 @@ build:
     - bash $SRC_DIR/build_ament_cmake.sh
 
 about:
-  repository: https://github.com/deepmodeling/Uni-Lab-OS
+  repository: https://github.com/dptech-corp/Uni-Lab-OS
   license: BSD-3-Clause
   description: "ros-humble-unilabos-msgs is a package that provides message definitions for Uni-Lab-OS."
 

recipes/unilabos/recipe.yaml

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

scripts/create_readme.py

@@ -126,7 +126,7 @@ If installation fails:
 For more help:
   - Documentation: docs/user_guide/installation.md
   - Quick Start: QUICK_START_CONDA_PACK.md
-  - Issues: https://github.com/deepmodeling/Uni-Lab-OS/issues
+  - Issues: https://github.com/dptech-corp/Uni-Lab-OS/issues
 
 License:
 --------
@@ -134,7 +134,7 @@ License:
 UniLabOS is licensed under GPL-3.0-only.
 See LICENSE file for details.
 
-Repository: https://github.com/deepmodeling/Uni-Lab-OS
+Repository: https://github.com/dptech-corp/Uni-Lab-OS
 """
 
     return readme

scripts/workflow.py

@@ -2,7 +2,6 @@ import json
 import logging
 import traceback
 import uuid
-import xml.etree.ElementTree as ET
 from typing import Any, Dict, List
 
 import networkx as nx
@@ -25,7 +24,15 @@ class SimpleGraph:
 
     def add_edge(self, source, target, **attrs):
         """添加边"""
-        edge = {"source": source, "target": 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
+        }
         self.edges.append(edge)
 
     def to_dict(self):
@@ -42,6 +49,7 @@ class SimpleGraph:
             "multigraph": False,
             "graph": {},
             "nodes": nodes_list,
+            "edges": self.edges,
             "links": self.edges,
         }
 
@@ -58,495 +66,8 @@ 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.10.14',
+    version='0.10.13',
     packages=find_packages(),
     include_package_data=True,
     install_requires=['setuptools'],

tests/devices/liquid_handling/README.md

@@ -0,0 +1,15 @@
+# Liquid handling 集成测试
+
+`test_transfer_liquid.py` 现在会调用 PRCXI 的 RViz 仿真 backend，运行前请确保：
+
+1. 已安装包含 `pylabrobot`、`rclpy` 的运行环境；
+2. 启动 ROS 依赖（`rviz` 可选，但是 `rviz_backend` 会创建 ROS 节点）；
+3. 在 shell 中设置 `UNILAB_SIM_TEST=1`，否则 pytest 会自动跳过这些慢速用例：
+
+```bash
+export UNILAB_SIM_TEST=1
+pytest tests/devices/liquid_handling/test_transfer_liquid.py -m slow
+```
+
+如果只需验证逻辑层（不依赖仿真），可以直接运行 `tests/devices/liquid_handling/unit_test.py`，该文件使用 Fake backend，适合作为 CI 的快速测试。***
+

tests/devices/liquid_handling/test_transfer_liquid.py

@@ -1,505 +1,337 @@
+"""
+PRCXI transfer_liquid 集成测试。
+
+这些用例会启动 UniLiquidHandler RViz 仿真 backend，需要同时满足：
+1. 安装 pylabrobot 依赖；
+2. 设置环境变量 UNILAB_SIM_TEST=1；
+3. 具备 ROS 运行环境（rviz_backend 会创建 ROS 节点）。
+"""
 import asyncio
+import os
 from dataclasses import dataclass
-from typing import Any, Iterable, List, Optional, Sequence, Tuple
+from typing import List, Sequence
 
 import pytest
 
 from unilabos.devices.liquid_handling.liquid_handler_abstract import LiquidHandlerAbstract
+from unilabos.devices.liquid_handling.prcxi.prcxi import PRCXI9300Deck, PRCXI9300Trash
+from unilabos.devices.liquid_handling.prcxi.prcxi_labware import (
+    PRCXI_300ul_Tips,
+    PRCXI_BioER_96_wellplate,
+)
+
+pytestmark = pytest.mark.slow
+
+try:
+    from pylabrobot.resources import Coordinate, Deck, Plate, TipRack, Well
+except ImportError:  # pragma: no cover - 测试环境缺少 pylabrobot 时直接跳过
+    Coordinate = Deck = Plate = TipRack = Well = None  # type: ignore[assignment]
+    PYLABROBOT_AVAILABLE = False
+else:
+    PYLABROBOT_AVAILABLE = True
+
+SIM_ENV_VAR = "UNILAB_SIM_TEST"
 
 
-@dataclass(frozen=True)
-class DummyContainer:
-    name: str
-
-    def __repr__(self) -> str:  # pragma: no cover
-        return f"DummyContainer({self.name})"
-
-
-@dataclass(frozen=True)
-class DummyTipSpot:
-    name: str
-
-    def __repr__(self) -> str:  # pragma: no cover
-        return f"DummyTipSpot({self.name})"
-
-
-def make_tip_iter(n: int = 256) -> Iterable[List[DummyTipSpot]]:
-    """Yield lists so code can safely call `tip.extend(next(self.current_tip))`."""
-    for i in range(n):
-        yield [DummyTipSpot(f"tip_{i}")]
-
-
-class FakeLiquidHandler(LiquidHandlerAbstract):
-    """不初始化真实 backend/deck；仅用来记录 transfer_liquid 内部调用序列。"""
-
-    def __init__(self, channel_num: int = 8):
-        # 不调用 super().__init__，避免真实硬件/后端依赖
-        self.channel_num = channel_num
-        self.support_touch_tip = True
-        self.current_tip = iter(make_tip_iter())
-        self.calls: List[Tuple[str, Any]] = []
-
-    async def pick_up_tips(self, tip_spots, use_channels=None, offsets=None, **backend_kwargs):
-        self.calls.append(("pick_up_tips", {"tips": list(tip_spots), "use_channels": use_channels}))
-
-    async def aspirate(
-        self,
-        resources: Sequence[Any],
-        vols: List[float],
-        use_channels: Optional[List[int]] = None,
-        flow_rates: Optional[List[Optional[float]]] = None,
-        offsets: Any = None,
-        liquid_height: Any = None,
-        blow_out_air_volume: Any = None,
-        spread: str = "wide",
-        **backend_kwargs,
-    ):
-        self.calls.append(
-            (
-                "aspirate",
-                {
-                    "resources": list(resources),
-                    "vols": list(vols),
-                    "use_channels": list(use_channels) if use_channels is not None else None,
-                    "flow_rates": list(flow_rates) if flow_rates is not None else None,
-                    "offsets": list(offsets) if offsets is not None else None,
-                    "liquid_height": list(liquid_height) if liquid_height is not None else None,
-                    "blow_out_air_volume": list(blow_out_air_volume) if blow_out_air_volume is not None else None,
-                },
-            )
-        )
-
-    async def dispense(
-        self,
-        resources: Sequence[Any],
-        vols: List[float],
-        use_channels: Optional[List[int]] = None,
-        flow_rates: Optional[List[Optional[float]]] = None,
-        offsets: Any = None,
-        liquid_height: Any = None,
-        blow_out_air_volume: Any = None,
-        spread: str = "wide",
-        **backend_kwargs,
-    ):
-        self.calls.append(
-            (
-                "dispense",
-                {
-                    "resources": list(resources),
-                    "vols": list(vols),
-                    "use_channels": list(use_channels) if use_channels is not None else None,
-                    "flow_rates": list(flow_rates) if flow_rates is not None else None,
-                    "offsets": list(offsets) if offsets is not None else None,
-                    "liquid_height": list(liquid_height) if liquid_height is not None else None,
-                    "blow_out_air_volume": list(blow_out_air_volume) if blow_out_air_volume is not None else None,
-                },
-            )
-        )
-
-    async def discard_tips(self, use_channels=None, *args, **kwargs):
-        # 有的分支是 discard_tips(use_channels=[0])，有的分支是 discard_tips([0..7])（位置参数）
-        self.calls.append(("discard_tips", {"use_channels": list(use_channels) if use_channels is not None else None}))
-
-    async def custom_delay(self, seconds=0, msg=None):
-        self.calls.append(("custom_delay", {"seconds": seconds, "msg": msg}))
-
-    async def touch_tip(self, targets):
-        # 原实现会访问 targets.get_size_x() 等；测试里只记录调用
-        self.calls.append(("touch_tip", {"targets": targets}))
-
-    async def mix(self, targets, mix_time=None, mix_vol=None, height_to_bottom=None, offsets=None, mix_rate=None, none_keys=None):
-        self.calls.append(
-            (
-                "mix",
-                {
-                    "targets": targets,
-                    "mix_time": mix_time,
-                    "mix_vol": mix_vol,
-                },
-            )
-        )
+@dataclass
+class SimulationContext:
+    handler: LiquidHandlerAbstract
+    deck: Deck
+    tip_rack: TipRack
+    source_plate: Plate
+    target_plate: Plate
+    waste_plate: Plate
+    channel_num: int
 
 
 def run(coro):
     return asyncio.run(coro)
 
 
-def test_one_to_one_single_channel_basic_calls():
-    lh = FakeLiquidHandler(channel_num=1)
-    lh.current_tip = iter(make_tip_iter(64))
+def _ensure_unilabos_extra(well: Well) -> None:
+    if not hasattr(well, "unilabos_extra") or well.unilabos_extra is None:
+        well.unilabos_extra = {}  # type: ignore[attr-defined]
 
-    sources = [DummyContainer(f"S{i}") for i in range(3)]
-    targets = [DummyContainer(f"T{i}") for i in range(3)]
 
-    run(
-        lh.transfer_liquid(
+def _assign_sample_uuid(well: Well, value: str) -> None:
+    _ensure_unilabos_extra(well)
+    well.unilabos_extra["sample_uuid"] = value  # type: ignore[attr-defined]
+
+
+def _zero_coordinate() -> Coordinate:
+    if hasattr(Coordinate, "zero"):
+        return Coordinate.zero()
+    return Coordinate(0, 0, 0)
+
+
+def _zero_offsets(count: int) -> List[Coordinate]:
+    return [_zero_coordinate() for _ in range(count)]
+
+
+def _build_simulation_deck() -> tuple[PRCXI9300Deck, TipRack, Plate, Plate, Plate, PRCXI9300Trash]:
+    deck = PRCXI9300Deck(name="PRCXI_Deck", size_x=542, size_y=374, size_z=50)
+    tip_rack = PRCXI_300ul_Tips("Tips")
+    source_plate = PRCXI_BioER_96_wellplate("SourcePlate")
+    target_plate = PRCXI_BioER_96_wellplate("TargetPlate")
+    waste_plate = PRCXI_BioER_96_wellplate("WastePlate")
+    trash = PRCXI9300Trash(name="trash", size_x=100, size_y=100, size_z=50)
+    deck.assign_child_resource(tip_rack, location=Coordinate(0, 0, 0))
+    deck.assign_child_resource(source_plate, location=Coordinate(150, 0, 0))
+    deck.assign_child_resource(target_plate, location=Coordinate(300, 0, 0))
+    deck.assign_child_resource(waste_plate, location=Coordinate(450, 0, 0))
+    deck.assign_child_resource(trash, location=Coordinate(150, -120, 0))
+    return deck, tip_rack, source_plate, target_plate, waste_plate, trash
+
+
+def _stop_backend(handler: LiquidHandlerAbstract) -> None:
+    try:
+        run(handler.backend.stop())
+    except Exception:  # pragma: no cover - 如果 backend 已经停止
+        pass
+    simulate_handler = getattr(handler, "_simulate_handler", None)
+    if simulate_handler is not None and getattr(simulate_handler, "backend", None) is not None:
+        try:
+            run(simulate_handler.backend.stop())
+        except Exception:  # pragma: no cover
+            pass
+
+
+@pytest.fixture(params=[1, 8])
+def prcxi_simulation(request) -> SimulationContext:
+    if not PYLABROBOT_AVAILABLE:
+        pytest.skip("pylabrobot is required for PRCXI simulation tests.")
+    if os.environ.get(SIM_ENV_VAR) != "1":
+        pytest.skip(f"Set {SIM_ENV_VAR}=1 to run PRCXI simulation tests.")
+
+    channel_num = request.param
+    deck, tip_rack, source_plate, target_plate, waste_plate, _trash = _build_simulation_deck()
+    backend_cfg = {
+        "type": "unilabos.devices.liquid_handling.rviz_backend.UniLiquidHandlerRvizBackend",
+        "channel_num": channel_num,
+        "total_height": 310,
+        "lh_device_id": f"pytest_prcxi_{channel_num}",
+    }
+    handler = LiquidHandlerAbstract(
+        backend=backend_cfg,
+        deck=deck,
+        simulator=True,
+        channel_num=channel_num,
+        total_height=310,
+    )
+    run(handler.setup())
+    handler.set_tiprack([tip_rack])
+    handler.support_touch_tip = False
+
+    context = SimulationContext(
+        handler=handler,
+        deck=deck,
+        tip_rack=tip_rack,
+        source_plate=source_plate,
+        target_plate=target_plate,
+        waste_plate=waste_plate,
+        channel_num=channel_num,
+    )
+
+    yield context
+
+    _stop_backend(handler)
+
+
+def _pick_wells(plate: Plate, start: int, count: int) -> List[Well]:
+    wells = plate.children[start : start + count]
+    for well in wells:
+        _ensure_unilabos_extra(well)
+    return wells
+
+
+def _assert_samples_match(sources: Sequence[Well], targets: Sequence[Well]) -> None:
+    for src, tgt in zip(sources, targets):
+        src_uuid = getattr(src, "unilabos_extra", {}).get("sample_uuid")
+        tgt_uuid = getattr(tgt, "unilabos_extra", {}).get("sample_uuid")
+        assert tgt_uuid == src_uuid
+
+
+def test_transfer_liquid_single_channel_one_to_one(prcxi_simulation: SimulationContext):
+    if prcxi_simulation.channel_num != 1:
+        pytest.skip("仅在单通道配置下运行")
+
+    handler = prcxi_simulation.handler
+    for well in prcxi_simulation.source_plate.children + prcxi_simulation.target_plate.children:
+        _ensure_unilabos_extra(well)
+    sources = prcxi_simulation.source_plate[0:3]
+    targets = prcxi_simulation.target_plate["A4:A6"]
+    for idx, src in enumerate(sources):
+        _assign_sample_uuid(src, f"single_{idx}")
+    offsets = _zero_offsets(max(len(sources), len(targets)))
+
+    result = run(
+        handler.transfer_liquid(
             sources=sources,
             targets=targets,
-            tip_racks=[],
+            tip_racks=[prcxi_simulation.tip_rack],
             use_channels=[0],
-            asp_vols=[1, 2, 3],
-            dis_vols=[4, 5, 6],
-            mix_times=None,  # 应该仍能执行（不 mix）
+            asp_vols=[5.0, 6.0, 7.0],
+            dis_vols=[10.0, 11.0, 12.0],
+            offsets=offsets,
+            mix_times=None,
         )
     )
 
-    assert [c[0] for c in lh.calls].count("pick_up_tips") == 3
-    assert [c[0] for c in lh.calls].count("aspirate") == 3
-    assert [c[0] for c in lh.calls].count("dispense") == 3
-    assert [c[0] for c in lh.calls].count("discard_tips") == 3
+    # assert result == """"""
 
-    # 每次 aspirate/dispense 都是单孔列表
-    aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
-    assert aspirates[0]["resources"] == [sources[0]]
-    assert aspirates[0]["vols"] == [1.0]
-
-    dispenses = [payload for name, payload in lh.calls if name == "dispense"]
-    assert dispenses[2]["resources"] == [targets[2]]
-    assert dispenses[2]["vols"] == [6.0]
+    _assert_samples_match(sources, targets)
 
 
-def test_one_to_one_single_channel_before_stage_mixes_prior_to_aspirate():
-    lh = FakeLiquidHandler(channel_num=1)
-    lh.current_tip = iter(make_tip_iter(16))
+def test_transfer_liquid_single_channel_one_to_many(prcxi_simulation: SimulationContext):
+    if prcxi_simulation.channel_num != 1:
+        pytest.skip("仅在单通道配置下运行")
 
-    source = DummyContainer("S0")
-    target = DummyContainer("T0")
+    handler = prcxi_simulation.handler
+    for well in prcxi_simulation.source_plate.children + prcxi_simulation.target_plate.children:
+        _ensure_unilabos_extra(well)
+    source = prcxi_simulation.source_plate.children[0] 
+    targets = prcxi_simulation.target_plate["A1:E1"]
+    _assign_sample_uuid(source, "one_to_many_source")
+    offsets = _zero_offsets(max(len(targets), 1))
 
     run(
-        lh.transfer_liquid(
+        handler.transfer_liquid(
             sources=[source],
-            targets=[target],
-            tip_racks=[],
+            targets=targets,
+            tip_racks=[prcxi_simulation.tip_rack],
             use_channels=[0],
-            asp_vols=[5],
-            dis_vols=[5],
-            mix_stage="before",
+            asp_vols=10.0,
+            dis_vols=[2.0, 2.0, 2.0, 2.0, 2.0],
+            offsets=offsets,
+            mix_times=0,
+        )
+    )
+
+    for target in targets:
+        assert getattr(target, "unilabos_extra", {}).get("sample_uuid") == "one_to_many_source"
+
+
+def test_transfer_liquid_single_channel_many_to_one(prcxi_simulation: SimulationContext):
+    if prcxi_simulation.channel_num != 1:
+        pytest.skip("仅在单通道配置下运行")
+
+    handler = prcxi_simulation.handler
+    for well in prcxi_simulation.source_plate.children + prcxi_simulation.target_plate.children:
+        _ensure_unilabos_extra(well)
+    sources = prcxi_simulation.source_plate[0:3]
+    target = prcxi_simulation.target_plate.children[4]
+    for idx, src in enumerate(sources):
+        _assign_sample_uuid(src, f"many_to_one_{idx}")
+    offsets = _zero_offsets(max(len(sources), len([target])))
+
+    run(
+        handler.transfer_liquid(
+            sources=sources,
+            targets=[target],
+            tip_racks=[prcxi_simulation.tip_rack],
+            use_channels=[0],
+            asp_vols=[8.0, 9.0, 10.0],
+            dis_vols=1,
+            offsets=offsets,
+            mix_stage="after",
             mix_times=1,
+            mix_vol=5,
+        )
+    )
+
+    assert getattr(target, "unilabos_extra", {}).get("sample_uuid") == "many_to_one_2"
+
+
+def test_transfer_liquid_eight_channel_batches(prcxi_simulation: SimulationContext):
+    if prcxi_simulation.channel_num != 8:
+        pytest.skip("仅在八通道配置下运行")
+
+    handler = prcxi_simulation.handler
+    for well in prcxi_simulation.source_plate.children + prcxi_simulation.target_plate.children:
+        _ensure_unilabos_extra(well)
+    sources = prcxi_simulation.source_plate[0:8]
+    targets = prcxi_simulation.target_plate[16:24]
+    for idx, src in enumerate(sources):
+        _assign_sample_uuid(src, f"batch_{idx}")
+    offsets = _zero_offsets(len(targets))
+
+    use_channels = list(range(8))
+    asp_vols = [float(i + 1) * 2 for i in range(8)]
+    dis_vols = [float(i + 10) for i in range(8)]
+
+    run(
+        handler.transfer_liquid(
+            sources=sources,
+            targets=targets,
+            tip_racks=[prcxi_simulation.tip_rack],
+            use_channels=use_channels,
+            asp_vols=asp_vols,
+            dis_vols=dis_vols,
+            offsets=offsets,
+            mix_times=0,
+        )
+    )
+
+    _assert_samples_match(sources, targets)
+
+
+@pytest.mark.parametrize("mix_stage", ["before", "after", "both"])
+def test_transfer_liquid_mix_stages(prcxi_simulation: SimulationContext, mix_stage: str):
+    if prcxi_simulation.channel_num != 1:
+        pytest.skip("仅在单通道配置下运行")
+
+    handler = prcxi_simulation.handler
+    for well in prcxi_simulation.source_plate.children + prcxi_simulation.target_plate.children:
+        _ensure_unilabos_extra(well)
+    target = prcxi_simulation.target_plate[70]
+    sources = prcxi_simulation.source_plate[80:82]
+    for idx, src in enumerate(sources):
+        _assign_sample_uuid(src, f"mix_stage_{mix_stage}_{idx}")
+
+    run(
+        handler.transfer_liquid(
+            sources=sources,
+            targets=[target],
+            tip_racks=[prcxi_simulation.tip_rack],
+            use_channels=[0],
+            asp_vols=[4.0, 5.0],
+            dis_vols=1,
+            offsets=_zero_offsets(len(sources)),
+            mix_stage=mix_stage,
+            mix_times=2,
             mix_vol=3,
         )
     )
 
-    names = [name for name, _ in lh.calls]
-    assert names.count("mix") == 1
-    assert names.index("mix") < names.index("aspirate")
+    # mix_stage 前后都应该保留最新源的 sample_uuid
+    assert getattr(target, "unilabos_extra", {}).get("sample_uuid") == f"mix_stage_{mix_stage}_1"
+    if prcxi_simulation.channel_num != 8:
+        pytest.skip("仅在八通道配置下运行")
 
+    handler = prcxi_simulation.handler
+    sources = prcxi_simulation.source_plate[0:8]
+    targets = prcxi_simulation.target_plate[16:24]
+    for idx, src in enumerate(sources):
+        _assign_sample_uuid(src, f"batch_{idx}")
+    offsets = _zero_offsets(len(targets))
 
-def test_one_to_one_eight_channel_groups_by_8():
-    lh = FakeLiquidHandler(channel_num=8)
-    lh.current_tip = iter(make_tip_iter(256))
-
-    sources = [DummyContainer(f"S{i}") for i in range(16)]
-    targets = [DummyContainer(f"T{i}") for i in range(16)]
-    asp_vols = list(range(1, 17))
-    dis_vols = list(range(101, 117))
+    use_channels = list(range(8))
+    asp_vols = [float(i + 1) * 2 for i in range(8)]
+    dis_vols = [float(i + 10) for i in range(8)]
 
     run(
-        lh.transfer_liquid(
+        handler.transfer_liquid(
             sources=sources,
             targets=targets,
-            tip_racks=[],
-            use_channels=list(range(8)),
+            tip_racks=[prcxi_simulation.tip_rack],
+            use_channels=use_channels,
             asp_vols=asp_vols,
             dis_vols=dis_vols,
-            mix_times=0,  # 触发逻辑但不 mix
-        )
-    )
-
-    # 16 个任务 -> 2 组，每组 8 通道一起做
-    assert [c[0] for c in lh.calls].count("pick_up_tips") == 2
-    aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
-    dispenses = [payload for name, payload in lh.calls if name == "dispense"]
-    assert len(aspirates) == 2
-    assert len(dispenses) == 2
-
-    assert aspirates[0]["resources"] == sources[0:8]
-    assert aspirates[0]["vols"] == [float(v) for v in asp_vols[0:8]]
-    assert dispenses[1]["resources"] == targets[8:16]
-    assert dispenses[1]["vols"] == [float(v) for v in dis_vols[8:16]]
-
-
-def test_one_to_one_eight_channel_requires_multiple_of_8_targets():
-    lh = FakeLiquidHandler(channel_num=8)
-    lh.current_tip = iter(make_tip_iter(64))
-
-    sources = [DummyContainer(f"S{i}") for i in range(9)]
-    targets = [DummyContainer(f"T{i}") for i in range(9)]
-
-    with pytest.raises(ValueError, match="multiple of 8"):
-        run(
-            lh.transfer_liquid(
-                sources=sources,
-                targets=targets,
-                tip_racks=[],
-                use_channels=list(range(8)),
-                asp_vols=[1] * 9,
-                dis_vols=[1] * 9,
-                mix_times=0,
-            )
-        )
-
-
-def test_one_to_one_eight_channel_parameter_lists_are_chunked_per_8():
-    lh = FakeLiquidHandler(channel_num=8)
-    lh.current_tip = iter(make_tip_iter(512))
-
-    sources = [DummyContainer(f"S{i}") for i in range(16)]
-    targets = [DummyContainer(f"T{i}") for i in range(16)]
-    asp_vols = [i + 1 for i in range(16)]
-    dis_vols = [200 + i for i in range(16)]
-    asp_flow_rates = [0.1 * (i + 1) for i in range(16)]
-    dis_flow_rates = [0.2 * (i + 1) for i in range(16)]
-    offsets = [f"offset_{i}" for i in range(16)]
-    liquid_heights = [i * 0.5 for i in range(16)]
-    blow_out_air_volume = [i + 0.05 for i in range(16)]
-
-    run(
-        lh.transfer_liquid(
-            sources=sources,
-            targets=targets,
-            tip_racks=[],
-            use_channels=list(range(8)),
-            asp_vols=asp_vols,
-            dis_vols=dis_vols,
-            asp_flow_rates=asp_flow_rates,
-            dis_flow_rates=dis_flow_rates,
             offsets=offsets,
-            liquid_height=liquid_heights,
-            blow_out_air_volume=blow_out_air_volume,
-            mix_times=0,
-        )
-    )
-
-    aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
-    dispenses = [payload for name, payload in lh.calls if name == "dispense"]
-    assert len(aspirates) == len(dispenses) == 2
-
-    for batch_idx in range(2):
-        start = batch_idx * 8
-        end = start + 8
-        asp_call = aspirates[batch_idx]
-        dis_call = dispenses[batch_idx]
-        assert asp_call["resources"] == sources[start:end]
-        assert asp_call["flow_rates"] == asp_flow_rates[start:end]
-        assert asp_call["offsets"] == offsets[start:end]
-        assert asp_call["liquid_height"] == liquid_heights[start:end]
-        assert asp_call["blow_out_air_volume"] == blow_out_air_volume[start:end]
-        assert dis_call["flow_rates"] == dis_flow_rates[start:end]
-        assert dis_call["offsets"] == offsets[start:end]
-        assert dis_call["liquid_height"] == liquid_heights[start:end]
-        assert dis_call["blow_out_air_volume"] == blow_out_air_volume[start:end]
-
-
-def test_one_to_one_eight_channel_handles_32_tasks_four_batches():
-    lh = FakeLiquidHandler(channel_num=8)
-    lh.current_tip = iter(make_tip_iter(1024))
-
-    sources = [DummyContainer(f"S{i}") for i in range(32)]
-    targets = [DummyContainer(f"T{i}") for i in range(32)]
-    asp_vols = [i + 1 for i in range(32)]
-    dis_vols = [300 + i for i in range(32)]
-
-    run(
-        lh.transfer_liquid(
-            sources=sources,
-            targets=targets,
-            tip_racks=[],
-            use_channels=list(range(8)),
-            asp_vols=asp_vols,
-            dis_vols=dis_vols,
-            mix_times=0,
-        )
-    )
-
-    pick_calls = [name for name, _ in lh.calls if name == "pick_up_tips"]
-    aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
-    dispenses = [payload for name, payload in lh.calls if name == "dispense"]
-    assert len(pick_calls) == 4
-    assert len(aspirates) == len(dispenses) == 4
-    assert aspirates[0]["resources"] == sources[0:8]
-    assert aspirates[-1]["resources"] == sources[24:32]
-    assert dispenses[0]["resources"] == targets[0:8]
-    assert dispenses[-1]["resources"] == targets[24:32]
-
-
-def test_one_to_many_single_channel_aspirates_total_when_asp_vol_too_small():
-    lh = FakeLiquidHandler(channel_num=1)
-    lh.current_tip = iter(make_tip_iter(64))
-
-    source = DummyContainer("SRC")
-    targets = [DummyContainer(f"T{i}") for i in range(3)]
-    dis_vols = [10, 20, 30]  # sum=60
-
-    run(
-        lh.transfer_liquid(
-            sources=[source],
-            targets=targets,
-            tip_racks=[],
-            use_channels=[0],
-            asp_vols=10,  # 小于 sum(dis_vols) -> 应吸 60
-            dis_vols=dis_vols,
-            mix_times=0,
-        )
-    )
-
-    aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
-    assert len(aspirates) == 1
-    assert aspirates[0]["resources"] == [source]
-    assert aspirates[0]["vols"] == [60.0]
-    assert aspirates[0]["use_channels"] == [0]
-    dispenses = [payload for name, payload in lh.calls if name == "dispense"]
-    assert [d["vols"][0] for d in dispenses] == [10.0, 20.0, 30.0]
-
-
-def test_one_to_many_eight_channel_basic():
-    lh = FakeLiquidHandler(channel_num=8)
-    lh.current_tip = iter(make_tip_iter(128))
-
-    source = DummyContainer("SRC")
-    targets = [DummyContainer(f"T{i}") for i in range(8)]
-    dis_vols = [i + 1 for i in range(8)]
-
-    run(
-        lh.transfer_liquid(
-            sources=[source],
-            targets=targets,
-            tip_racks=[],
-            use_channels=list(range(8)),
-            asp_vols=999,  # one-to-many 8ch 会按 dis_vols 吸（每通道各自）
-            dis_vols=dis_vols,
-            mix_times=0,
-        )
-    )
-
-    aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
-    assert aspirates[0]["resources"] == [source] * 8
-    assert aspirates[0]["vols"] == [float(v) for v in dis_vols]
-    dispenses = [payload for name, payload in lh.calls if name == "dispense"]
-    assert dispenses[0]["resources"] == targets
-    assert dispenses[0]["vols"] == [float(v) for v in dis_vols]
-
-
-def test_many_to_one_single_channel_standard_dispense_equals_asp_by_default():
-    lh = FakeLiquidHandler(channel_num=1)
-    lh.current_tip = iter(make_tip_iter(128))
-
-    sources = [DummyContainer(f"S{i}") for i in range(3)]
-    target = DummyContainer("T")
-    asp_vols = [5, 6, 7]
-
-    run(
-        lh.transfer_liquid(
-            sources=sources,
-            targets=[target],
-            tip_racks=[],
-            use_channels=[0],
-            asp_vols=asp_vols,
-            dis_vols=1,  # many-to-one 允许标量；非比例模式下实际每次分液=对应 asp_vol
-            mix_times=0,
-        )
-    )
-
-    dispenses = [payload for name, payload in lh.calls if name == "dispense"]
-    assert [d["vols"][0] for d in dispenses] == [float(v) for v in asp_vols]
-    assert all(d["resources"] == [target] for d in dispenses)
-
-
-def test_many_to_one_single_channel_before_stage_mixes_target_once():
-    lh = FakeLiquidHandler(channel_num=1)
-    lh.current_tip = iter(make_tip_iter(128))
-
-    sources = [DummyContainer("S0"), DummyContainer("S1")]
-    target = DummyContainer("T")
-
-    run(
-        lh.transfer_liquid(
-            sources=sources,
-            targets=[target],
-            tip_racks=[],
-            use_channels=[0],
-            asp_vols=[5, 6],
-            dis_vols=1,
-            mix_stage="before",
+            mix_stage="after",
             mix_times=2,
-            mix_vol=4,
+            mix_vol=3,
         )
     )
 
-    names = [name for name, _ in lh.calls]
-    assert names[0] == "mix"
-    assert names.count("mix") == 1
-
-
-def test_many_to_one_single_channel_proportional_mixing_uses_dis_vols_per_source():
-    lh = FakeLiquidHandler(channel_num=1)
-    lh.current_tip = iter(make_tip_iter(128))
-
-    sources = [DummyContainer(f"S{i}") for i in range(3)]
-    target = DummyContainer("T")
-    asp_vols = [5, 6, 7]
-    dis_vols = [1, 2, 3]
-
-    run(
-        lh.transfer_liquid(
-            sources=sources,
-            targets=[target],
-            tip_racks=[],
-            use_channels=[0],
-            asp_vols=asp_vols,
-            dis_vols=dis_vols,  # 比例模式
-            mix_times=0,
-        )
-    )
-
-    dispenses = [payload for name, payload in lh.calls if name == "dispense"]
-    assert [d["vols"][0] for d in dispenses] == [float(v) for v in dis_vols]
-
-
-def test_many_to_one_eight_channel_basic():
-    lh = FakeLiquidHandler(channel_num=8)
-    lh.current_tip = iter(make_tip_iter(256))
-
-    sources = [DummyContainer(f"S{i}") for i in range(8)]
-    target = DummyContainer("T")
-    asp_vols = [10 + i for i in range(8)]
-
-    run(
-        lh.transfer_liquid(
-            sources=sources,
-            targets=[target],
-            tip_racks=[],
-            use_channels=list(range(8)),
-            asp_vols=asp_vols,
-            dis_vols=999,  # 非比例模式下每通道分液=对应 asp_vol
-            mix_times=0,
-        )
-    )
-
-    aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
-    dispenses = [payload for name, payload in lh.calls if name == "dispense"]
-    assert aspirates[0]["resources"] == sources
-    assert aspirates[0]["vols"] == [float(v) for v in asp_vols]
-    assert dispenses[0]["resources"] == [target] * 8
-    assert dispenses[0]["vols"] == [float(v) for v in asp_vols]
-
-
-def test_transfer_liquid_mode_detection_unsupported_shape_raises():
-    lh = FakeLiquidHandler(channel_num=8)
-    lh.current_tip = iter(make_tip_iter(64))
-
-    sources = [DummyContainer("S0"), DummyContainer("S1")]
-    targets = [DummyContainer("T0"), DummyContainer("T1"), DummyContainer("T2")]
-
-    with pytest.raises(ValueError, match="Unsupported transfer mode"):
-        run(
-            lh.transfer_liquid(
-                sources=sources,
-                targets=targets,
-                tip_racks=[],
-                use_channels=[0],
-                asp_vols=[1, 1],
-                dis_vols=[1, 1, 1],
-                mix_times=0,
-            )
-        )
-
+    _assert_samples_match(sources, targets)

tests/devices/liquid_handling/unit_test.py

@@ -0,0 +1,547 @@
+import asyncio
+from dataclasses import dataclass
+from typing import Any, Iterable, List, Optional, Sequence, Tuple
+
+import pytest
+
+from unilabos.devices.liquid_handling.liquid_handler_abstract import LiquidHandlerAbstract
+
+
+@dataclass(frozen=True)
+class DummyContainer:
+    name: str
+
+    def __repr__(self) -> str:  # pragma: no cover
+        return f"DummyContainer({self.name})"
+
+
+@dataclass(frozen=True)
+class DummyTipSpot:
+    name: str
+
+    def __repr__(self) -> str:  # pragma: no cover
+        return f"DummyTipSpot({self.name})"
+
+
+def make_tip_iter(n: int = 256) -> Iterable[List[DummyTipSpot]]:
+    """Yield lists so code can safely call `tip.extend(next(self.current_tip))`."""
+    for i in range(n):
+        yield [DummyTipSpot(f"tip_{i}")]
+
+
+class FakeLiquidHandler(LiquidHandlerAbstract):
+    """不初始化真实 backend/deck；仅用来记录 transfer_liquid 内部调用序列。"""
+
+    def __init__(self, channel_num: int = 8):
+        # 不调用 super().__init__，避免真实硬件/后端依赖
+        self.channel_num = channel_num
+        self.support_touch_tip = True
+        self.current_tip = iter(make_tip_iter())
+        self.calls: List[Tuple[str, Any]] = []
+
+    async def pick_up_tips(self, tip_spots, use_channels=None, offsets=None, **backend_kwargs):
+        self.calls.append(("pick_up_tips", {"tips": list(tip_spots), "use_channels": use_channels}))
+
+    async def aspirate(
+        self,
+        resources: Sequence[Any],
+        vols: List[float],
+        use_channels: Optional[List[int]] = None,
+        flow_rates: Optional[List[Optional[float]]] = None,
+        offsets: Any = None,
+        liquid_height: Any = None,
+        blow_out_air_volume: Any = None,
+        spread: str = "wide",
+        **backend_kwargs,
+    ):
+        self.calls.append(
+            (
+                "aspirate",
+                {
+                    "resources": list(resources),
+                    "vols": list(vols),
+                    "use_channels": list(use_channels) if use_channels is not None else None,
+                    "flow_rates": list(flow_rates) if flow_rates is not None else None,
+                    "offsets": list(offsets) if offsets is not None else None,
+                    "liquid_height": list(liquid_height) if liquid_height is not None else None,
+                    "blow_out_air_volume": list(blow_out_air_volume) if blow_out_air_volume is not None else None,
+                },
+            )
+        )
+
+    async def dispense(
+        self,
+        resources: Sequence[Any],
+        vols: List[float],
+        use_channels: Optional[List[int]] = None,
+        flow_rates: Optional[List[Optional[float]]] = None,
+        offsets: Any = None,
+        liquid_height: Any = None,
+        blow_out_air_volume: Any = None,
+        spread: str = "wide",
+        **backend_kwargs,
+    ):
+        self.calls.append(
+            (
+                "dispense",
+                {
+                    "resources": list(resources),
+                    "vols": list(vols),
+                    "use_channels": list(use_channels) if use_channels is not None else None,
+                    "flow_rates": list(flow_rates) if flow_rates is not None else None,
+                    "offsets": list(offsets) if offsets is not None else None,
+                    "liquid_height": list(liquid_height) if liquid_height is not None else None,
+                    "blow_out_air_volume": list(blow_out_air_volume) if blow_out_air_volume is not None else None,
+                },
+            )
+        )
+
+    async def discard_tips(self, use_channels=None, *args, **kwargs):
+        # 有的分支是 discard_tips(use_channels=[0])，有的分支是 discard_tips([0..7])（位置参数）
+        self.calls.append(("discard_tips", {"use_channels": list(use_channels) if use_channels is not None else None}))
+
+    async def custom_delay(self, seconds=0, msg=None):
+        self.calls.append(("custom_delay", {"seconds": seconds, "msg": msg}))
+
+    async def touch_tip(self, targets):
+        # 原实现会访问 targets.get_size_x() 等；测试里只记录调用
+        self.calls.append(("touch_tip", {"targets": targets}))
+
+def run(coro):
+    return asyncio.run(coro)
+
+
+def test_one_to_one_single_channel_basic_calls():
+  lh = FakeLiquidHandler(channel_num=1)
+  lh.current_tip = iter(make_tip_iter(64))
+
+  sources = [DummyContainer(f"S{i}") for i in range(3)]
+  targets = [DummyContainer(f"T{i}") for i in range(3)]
+
+  run(
+    lh.transfer_liquid(
+      sources=sources,
+      targets=targets,
+      tip_racks=[],
+      use_channels=[0],
+      asp_vols=[1, 2, 3],
+      dis_vols=[4, 5, 6],
+      mix_times=None,  # 应该仍能执行（不 mix）
+    )
+  )
+
+  assert [c[0] for c in lh.calls].count("pick_up_tips") == 3
+  assert [c[0] for c in lh.calls].count("aspirate") == 3
+  assert [c[0] for c in lh.calls].count("dispense") == 3
+  assert [c[0] for c in lh.calls].count("discard_tips") == 3
+
+  # 每次 aspirate/dispense 都是单孔列表
+  aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
+  assert aspirates[0]["resources"] == [sources[0]]
+  assert aspirates[0]["vols"] == [1.0]
+
+  dispenses = [payload for name, payload in lh.calls if name == "dispense"]
+  assert dispenses[2]["resources"] == [targets[2]]
+  assert dispenses[2]["vols"] == [6.0]
+
+
+def test_one_to_one_single_channel_before_stage_mixes_prior_to_aspirate():
+  lh = FakeLiquidHandler(channel_num=1)
+  lh.current_tip = iter(make_tip_iter(16))
+
+  source = DummyContainer("S0")
+  target = DummyContainer("T0")
+
+  run(
+    lh.transfer_liquid(
+      sources=[source],
+      targets=[target],
+      tip_racks=[],
+      use_channels=[0],
+      asp_vols=[5],
+      dis_vols=[5],
+      mix_stage="before",
+      mix_times=1,
+      mix_vol=3,
+    )
+  )
+
+  aspirate_calls = [(idx, payload) for idx, (name, payload) in enumerate(lh.calls) if name == "aspirate"]
+  assert len(aspirate_calls) >= 2
+  mix_idx, mix_payload = aspirate_calls[0]
+  assert mix_payload["resources"] == [target]
+  assert mix_payload["vols"] == [3]
+  transfer_idx, transfer_payload = aspirate_calls[1]
+  assert transfer_payload["resources"] == [source]
+  assert mix_idx < transfer_idx
+
+
+def test_one_to_one_eight_channel_groups_by_8():
+  lh = FakeLiquidHandler(channel_num=8)
+  lh.current_tip = iter(make_tip_iter(256))
+
+  sources = [DummyContainer(f"S{i}") for i in range(16)]
+  targets = [DummyContainer(f"T{i}") for i in range(16)]
+  asp_vols = list(range(1, 17))
+  dis_vols = list(range(101, 117))
+
+  run(
+    lh.transfer_liquid(
+      sources=sources,
+      targets=targets,
+      tip_racks=[],
+      use_channels=list(range(8)),
+      asp_vols=asp_vols,
+      dis_vols=dis_vols,
+      mix_times=0,  # 触发逻辑但不 mix
+    )
+  )
+
+  # 16 个任务 -> 2 组，每组 8 通道一起做
+  assert [c[0] for c in lh.calls].count("pick_up_tips") == 2
+  aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
+  dispenses = [payload for name, payload in lh.calls if name == "dispense"]
+  assert len(aspirates) == 2
+  assert len(dispenses) == 2
+
+  assert aspirates[0]["resources"] == sources[0:8]
+  assert aspirates[0]["vols"] == [float(v) for v in asp_vols[0:8]]
+  assert dispenses[1]["resources"] == targets[8:16]
+  assert dispenses[1]["vols"] == [float(v) for v in dis_vols[8:16]]
+
+
+def test_one_to_one_eight_channel_requires_multiple_of_8_targets():
+  lh = FakeLiquidHandler(channel_num=8)
+  lh.current_tip = iter(make_tip_iter(64))
+
+  sources = [DummyContainer(f"S{i}") for i in range(9)]
+  targets = [DummyContainer(f"T{i}") for i in range(9)]
+
+  with pytest.raises(ValueError, match="multiple of 8"):
+    run(
+      lh.transfer_liquid(
+        sources=sources,
+        targets=targets,
+        tip_racks=[],
+        use_channels=list(range(8)),
+        asp_vols=[1] * 9,
+        dis_vols=[1] * 9,
+        mix_times=0,
+      )
+    )
+
+
+def test_one_to_one_eight_channel_parameter_lists_are_chunked_per_8():
+  lh = FakeLiquidHandler(channel_num=8)
+  lh.current_tip = iter(make_tip_iter(512))
+
+  sources = [DummyContainer(f"S{i}") for i in range(16)]
+  targets = [DummyContainer(f"T{i}") for i in range(16)]
+  asp_vols = [i + 1 for i in range(16)]
+  dis_vols = [200 + i for i in range(16)]
+  asp_flow_rates = [0.1 * (i + 1) for i in range(16)]
+  dis_flow_rates = [0.2 * (i + 1) for i in range(16)]
+  offsets = [f"offset_{i}" for i in range(16)]
+  liquid_heights = [i * 0.5 for i in range(16)]
+  blow_out_air_volume = [i + 0.05 for i in range(16)]
+
+  run(
+    lh.transfer_liquid(
+      sources=sources,
+      targets=targets,
+      tip_racks=[],
+      use_channels=list(range(8)),
+      asp_vols=asp_vols,
+      dis_vols=dis_vols,
+      asp_flow_rates=asp_flow_rates,
+      dis_flow_rates=dis_flow_rates,
+      offsets=offsets,
+      liquid_height=liquid_heights,
+      blow_out_air_volume=blow_out_air_volume,
+      mix_times=0,
+    )
+  )
+
+  aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
+  dispenses = [payload for name, payload in lh.calls if name == "dispense"]
+  assert len(aspirates) == len(dispenses) == 2
+
+  for batch_idx in range(2):
+    start = batch_idx * 8
+    end = start + 8
+    asp_call = aspirates[batch_idx]
+    dis_call = dispenses[batch_idx]
+    assert asp_call["resources"] == sources[start:end]
+    assert asp_call["flow_rates"] == asp_flow_rates[start:end]
+    assert asp_call["offsets"] == offsets[start:end]
+    assert asp_call["liquid_height"] == liquid_heights[start:end]
+    assert asp_call["blow_out_air_volume"] == blow_out_air_volume[start:end]
+    assert dis_call["flow_rates"] == dis_flow_rates[start:end]
+    assert dis_call["offsets"] == offsets[start:end]
+    assert dis_call["liquid_height"] == liquid_heights[start:end]
+    assert dis_call["blow_out_air_volume"] == blow_out_air_volume[start:end]
+
+
+def test_one_to_one_eight_channel_handles_32_tasks_four_batches():
+  lh = FakeLiquidHandler(channel_num=8)
+  lh.current_tip = iter(make_tip_iter(1024))
+
+  sources = [DummyContainer(f"S{i}") for i in range(32)]
+  targets = [DummyContainer(f"T{i}") for i in range(32)]
+  asp_vols = [i + 1 for i in range(32)]
+  dis_vols = [300 + i for i in range(32)]
+
+  run(
+    lh.transfer_liquid(
+      sources=sources,
+      targets=targets,
+      tip_racks=[],
+      use_channels=list(range(8)),
+      asp_vols=asp_vols,
+      dis_vols=dis_vols,
+      mix_times=0,
+    )
+  )
+
+  pick_calls = [name for name, _ in lh.calls if name == "pick_up_tips"]
+  aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
+  dispenses = [payload for name, payload in lh.calls if name == "dispense"]
+  assert len(pick_calls) == 4
+  assert len(aspirates) == len(dispenses) == 4
+  assert aspirates[0]["resources"] == sources[0:8]
+  assert aspirates[-1]["resources"] == sources[24:32]
+  assert dispenses[0]["resources"] == targets[0:8]
+  assert dispenses[-1]["resources"] == targets[24:32]
+
+
+def test_one_to_many_single_channel_aspirates_total_when_asp_vol_too_small():
+  lh = FakeLiquidHandler(channel_num=1)
+  lh.current_tip = iter(make_tip_iter(64))
+
+  source = DummyContainer("SRC")
+  targets = [DummyContainer(f"T{i}") for i in range(3)]
+  dis_vols = [10, 20, 30]  # sum=60
+
+  run(
+    lh.transfer_liquid(
+      sources=[source],
+      targets=targets,
+      tip_racks=[],
+      use_channels=[0],
+      asp_vols=10,  # 小于 sum(dis_vols) -> 应吸 60
+      dis_vols=dis_vols,
+      mix_times=0,
+    )
+  )
+
+  aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
+  assert len(aspirates) == 1
+  assert aspirates[0]["resources"] == [source]
+  assert aspirates[0]["vols"] == [60.0]
+  assert aspirates[0]["use_channels"] == [0]
+  dispenses = [payload for name, payload in lh.calls if name == "dispense"]
+  assert [d["vols"][0] for d in dispenses] == [10.0, 20.0, 30.0]
+
+
+def test_one_to_many_eight_channel_basic():
+  lh = FakeLiquidHandler(channel_num=8)
+  lh.current_tip = iter(make_tip_iter(128))
+
+  source = DummyContainer("SRC")
+  targets = [DummyContainer(f"T{i}") for i in range(8)]
+  dis_vols = [i + 1 for i in range(8)]
+
+  run(
+    lh.transfer_liquid(
+      sources=[source],
+      targets=targets,
+      tip_racks=[],
+      use_channels=list(range(8)),
+      asp_vols=999,  # one-to-many 8ch 会按 dis_vols 吸（每通道各自）
+      dis_vols=dis_vols,
+      mix_times=0,
+    )
+  )
+
+  aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
+  assert aspirates[0]["resources"] == [source] * 8
+  assert aspirates[0]["vols"] == [float(v) for v in dis_vols]
+  dispenses = [payload for name, payload in lh.calls if name == "dispense"]
+  assert dispenses[0]["resources"] == targets
+  assert dispenses[0]["vols"] == [float(v) for v in dis_vols]
+
+
+def test_many_to_one_single_channel_standard_dispense_equals_asp_by_default():
+  lh = FakeLiquidHandler(channel_num=1)
+  lh.current_tip = iter(make_tip_iter(128))
+
+  sources = [DummyContainer(f"S{i}") for i in range(3)]
+  target = DummyContainer("T")
+  asp_vols = [5, 6, 7]
+
+  run(
+    lh.transfer_liquid(
+      sources=sources,
+      targets=[target],
+      tip_racks=[],
+      use_channels=[0],
+      asp_vols=asp_vols,
+      dis_vols=1,  # many-to-one 允许标量；非比例模式下实际每次分液=对应 asp_vol
+      mix_times=0,
+    )
+  )
+
+  dispenses = [payload for name, payload in lh.calls if name == "dispense"]
+  assert [d["vols"][0] for d in dispenses] == [float(v) for v in asp_vols]
+  assert all(d["resources"] == [target] for d in dispenses)
+
+
+def test_many_to_one_single_channel_before_stage_mixes_target_once():
+  lh = FakeLiquidHandler(channel_num=1)
+  lh.current_tip = iter(make_tip_iter(128))
+
+  sources = [DummyContainer("S0"), DummyContainer("S1")]
+  target = DummyContainer("T")
+
+  run(
+    lh.transfer_liquid(
+      sources=sources,
+      targets=[target],
+      tip_racks=[],
+      use_channels=[0],
+      asp_vols=[5, 6],
+      dis_vols=1,
+      mix_stage="before",
+      mix_times=2,
+      mix_vol=4,
+    )
+  )
+
+  aspirate_calls = [(idx, payload) for idx, (name, payload) in enumerate(lh.calls) if name == "aspirate"]
+  assert len(aspirate_calls) >= 1
+  mix_idx, mix_payload = aspirate_calls[0]
+  assert mix_payload["resources"] == [target]
+  assert mix_payload["vols"] == [4]
+  # 第一個 mix 之後會真正開始吸 source
+  assert any(call["resources"] == [sources[0]] for _, call in aspirate_calls[1:])
+
+
+def test_many_to_one_single_channel_proportional_mixing_uses_dis_vols_per_source():
+  lh = FakeLiquidHandler(channel_num=1)
+  lh.current_tip = iter(make_tip_iter(128))
+
+  sources = [DummyContainer(f"S{i}") for i in range(3)]
+  target = DummyContainer("T")
+  asp_vols = [5, 6, 7]
+  dis_vols = [1, 2, 3]
+
+  run(
+    lh.transfer_liquid(
+      sources=sources,
+      targets=[target],
+      tip_racks=[],
+      use_channels=[0],
+      asp_vols=asp_vols,
+      dis_vols=dis_vols,  # 比例模式
+      mix_times=0,
+    )
+  )
+
+  dispenses = [payload for name, payload in lh.calls if name == "dispense"]
+  assert [d["vols"][0] for d in dispenses] == [float(v) for v in dis_vols]
+
+
+def test_many_to_one_eight_channel_basic():
+  lh = FakeLiquidHandler(channel_num=8)
+  lh.current_tip = iter(make_tip_iter(256))
+
+  sources = [DummyContainer(f"S{i}") for i in range(8)]
+  target = DummyContainer("T")
+  asp_vols = [10 + i for i in range(8)]
+
+  run(
+    lh.transfer_liquid(
+      sources=sources,
+      targets=[target],
+      tip_racks=[],
+      use_channels=list(range(8)),
+      asp_vols=asp_vols,
+      dis_vols=999,  # 非比例模式下每通道分液=对应 asp_vol
+      mix_times=0,
+    )
+  )
+
+  aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
+  dispenses = [payload for name, payload in lh.calls if name == "dispense"]
+  assert aspirates[0]["resources"] == sources
+  assert aspirates[0]["vols"] == [float(v) for v in asp_vols]
+  assert dispenses[0]["resources"] == [target] * 8
+  assert dispenses[0]["vols"] == [float(v) for v in asp_vols]
+
+
+def test_transfer_liquid_mode_detection_unsupported_shape_raises():
+  lh = FakeLiquidHandler(channel_num=8)
+  lh.current_tip = iter(make_tip_iter(64))
+
+  sources = [DummyContainer("S0"), DummyContainer("S1")]
+  targets = [DummyContainer("T0"), DummyContainer("T1"), DummyContainer("T2")]
+
+  with pytest.raises(ValueError, match="Unsupported transfer mode"):
+    run(
+      lh.transfer_liquid(
+        sources=sources,
+        targets=targets,
+        tip_racks=[],
+        use_channels=[0],
+        asp_vols=[1, 1],
+        dis_vols=[1, 1, 1],
+        mix_times=0,
+      )
+    )
+
+
+def test_mix_single_target_produces_matching_cycles():
+  lh = FakeLiquidHandler(channel_num=1)
+  target = DummyContainer("T_mix")
+
+  run(lh.mix(targets=[target], mix_time=2, mix_vol=5))
+
+  aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
+  dispenses = [payload for name, payload in lh.calls if name == "dispense"]
+  assert len(aspirates) == len(dispenses) == 2
+  assert all(call["resources"] == [target] for call in aspirates)
+  assert all(call["vols"] == [5] for call in aspirates)
+  assert all(call["resources"] == [target] for call in dispenses)
+  assert all(call["vols"] == [5] for call in dispenses)
+
+
+def test_mix_multiple_targets_supports_per_target_offsets():
+  lh = FakeLiquidHandler(channel_num=1)
+  targets = [DummyContainer("T0"), DummyContainer("T1")]
+  offsets = ["left", "right"]
+  heights = [0.1, 0.2]
+  rates = [0.5, 1.0]
+
+  run(
+    lh.mix(
+      targets=targets,
+      mix_time=1,
+      mix_vol=3,
+      offsets=offsets,
+      height_to_bottom=heights,
+      mix_rate=rates,
+    )
+  )
+
+  aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
+  assert len(aspirates) == 2
+  assert aspirates[0]["resources"] == [targets[0]]
+  assert aspirates[0]["offsets"] == [offsets[0]]
+  assert aspirates[0]["liquid_height"] == [heights[0]]
+  assert aspirates[0]["flow_rates"] == [rates[0]]
+  assert aspirates[1]["resources"] == [targets[1]]
+  assert aspirates[1]["offsets"] == [offsets[1]]
+  assert aspirates[1]["liquid_height"] == [heights[1]]
+  assert aspirates[1]["flow_rates"] == [rates[1]]
+
+

unilabos/__init__.py

@@ -1 +1 @@
-__version__ = "0.10.14"
+__version__ = "0.10.13"

unilabos/app/main.py

@@ -20,6 +20,7 @@ if unilabos_dir not in sys.path:
 from unilabos.utils.banner_print import print_status, print_unilab_banner
 from unilabos.config.config import load_config, BasicConfig, HTTPConfig
 
+
 def load_config_from_file(config_path):
     if config_path is None:
         config_path = os.environ.get("UNILABOS_BASICCONFIG_CONFIG_PATH", None)
@@ -41,7 +42,7 @@ def convert_argv_dashes_to_underscores(args: argparse.ArgumentParser):
     for i, arg in enumerate(sys.argv):
         for option_string in option_strings:
             if arg.startswith(option_string):
-                new_arg = arg[:2] + arg[2:len(option_string)].replace("-", "_") + arg[len(option_string):]
+                new_arg = arg[:2] + arg[2 : len(option_string)].replace("-", "_") + arg[len(option_string) :]
                 sys.argv[i] = new_arg
                 break
 
@@ -49,6 +50,8 @@ def convert_argv_dashes_to_underscores(args: argparse.ArgumentParser):
 def parse_args():
     """解析命令行参数"""
     parser = argparse.ArgumentParser(description="Start Uni-Lab Edge server.")
+    subparsers = parser.add_subparsers(title="Valid subcommands", dest="command")
+
     parser.add_argument("-g", "--graph", help="Physical setup graph file path.")
     parser.add_argument("-c", "--controllers", default=None, help="Controllers config file path.")
     parser.add_argument(
@@ -153,6 +156,39 @@ def parse_args():
         default=False,
         help="Complete registry information",
     )
+    # workflow upload subcommand
+    workflow_parser = subparsers.add_parser(
+        "workflow_upload",
+        aliases=["wf"],
+        help="Upload workflow from xdl/json/python files",
+    )
+    workflow_parser.add_argument(
+        "-f",
+        "--workflow_file",
+        type=str,
+        required=True,
+        help="Path to the workflow file (JSON format)",
+    )
+    workflow_parser.add_argument(
+        "-n",
+        "--workflow_name",
+        type=str,
+        default=None,
+        help="Workflow name, if not provided will use the name from file or filename",
+    )
+    workflow_parser.add_argument(
+        "--tags",
+        type=str,
+        nargs="*",
+        default=[],
+        help="Tags for the workflow (space-separated)",
+    )
+    workflow_parser.add_argument(
+        "--published",
+        action="store_true",
+        default=False,
+        help="Whether to publish the workflow (default: False)",
+    )
     return parser
 
 
@@ -168,7 +204,6 @@ def main():
     if not args_dict.get("skip_env_check", False):
         from unilabos.utils.environment_check import check_environment
 
-        print_status("正在进行环境依赖检查...", "info")
         if not check_environment(auto_install=True):
             print_status("环境检查失败，程序退出", "error")
             os._exit(1)
@@ -241,9 +276,12 @@ def main():
     if args_dict.get("sk", ""):
         BasicConfig.sk = args_dict.get("sk", "")
         print_status("传入了sk参数，优先采用传入参数！", "info")
+    BasicConfig.working_dir = working_dir
+
+    workflow_upload = args_dict.get("command") in ("workflow_upload", "wf")
 
     # 使用远程资源启动
-    if args_dict["use_remote_resource"]:
+    if not workflow_upload and args_dict["use_remote_resource"]:
         print_status("使用远程资源启动", "info")
         from unilabos.app.web import http_client
 
@@ -256,7 +294,6 @@ def main():
 
     BasicConfig.port = args_dict["port"] if args_dict["port"] else BasicConfig.port
     BasicConfig.disable_browser = args_dict["disable_browser"] or BasicConfig.disable_browser
-    BasicConfig.working_dir = working_dir
     BasicConfig.is_host_mode = not args_dict.get("is_slave", False)
     BasicConfig.slave_no_host = args_dict.get("slave_no_host", False)
     BasicConfig.upload_registry = args_dict.get("upload_registry", False)
@@ -285,9 +322,31 @@ def main():
 
     # 注册表
     lab_registry = build_registry(
-        args_dict["registry_path"], args_dict.get("complete_registry", False), args_dict["upload_registry"]
+        args_dict["registry_path"], args_dict.get("complete_registry", False), BasicConfig.upload_registry
     )
 
+    if BasicConfig.upload_registry:
+        # 设备注册到服务端 - 需要 ak 和 sk
+        if BasicConfig.ak and BasicConfig.sk:
+            print_status("开始注册设备到服务端...", "info")
+            try:
+                register_devices_and_resources(lab_registry)
+                print_status("设备注册完成", "info")
+            except Exception as e:
+                print_status(f"设备注册失败: {e}", "error")
+        else:
+            print_status("未提供 ak 和 sk，跳过设备注册", "info")
+    else:
+        print_status("本次启动注册表不报送云端，如果您需要联网调试，请在启动命令增加--upload_registry", "warning")
+
+    # 处理 workflow_upload 子命令
+    if workflow_upload:
+        from unilabos.workflow.wf_utils import handle_workflow_upload_command
+
+        handle_workflow_upload_command(args_dict)
+        print_status("工作流上传完成，程序退出", "info")
+        os._exit(0)
+
     if not BasicConfig.ak or not BasicConfig.sk:
         print_status("后续运行必须拥有一个实验室，请前往 https://uni-lab.bohrium.com 注册实验室！", "warning")
         os._exit(1)
@@ -359,7 +418,7 @@ def main():
     # 如果从远端获取了物料信息，则与本地物料进行同步
     if request_startup_json and "nodes" in request_startup_json:
         print_status("开始同步远端物料到本地...", "info")
-        remote_tree_set = ResourceTreeSet.from_raw_dict_list(request_startup_json["nodes"])
+        remote_tree_set = ResourceTreeSet.from_raw_list(request_startup_json["nodes"])
         resource_tree_set.merge_remote_resources(remote_tree_set)
         print_status("远端物料同步完成", "info")
 
@@ -368,20 +427,6 @@ def main():
     args_dict["devices_config"] = resource_tree_set
     args_dict["graph"] = graph_res.physical_setup_graph
 
-    if BasicConfig.upload_registry:
-        # 设备注册到服务端 - 需要 ak 和 sk
-        if BasicConfig.ak and BasicConfig.sk:
-            print_status("开始注册设备到服务端...", "info")
-            try:
-                register_devices_and_resources(lab_registry)
-                print_status("设备注册完成", "info")
-            except Exception as e:
-                print_status(f"设备注册失败: {e}", "error")
-        else:
-            print_status("未提供 ak 和 sk，跳过设备注册", "info")
-    else:
-        print_status("本次启动注册表不报送云端，如果您需要联网调试，请在启动命令增加--upload_registry", "warning")
-
     if args_dict["controllers"] is not None:
         args_dict["controllers_config"] = yaml.safe_load(open(args_dict["controllers"], encoding="utf-8"))
     else:
@@ -396,6 +441,7 @@ def main():
         comm_client = get_communication_client()
         if "websocket" in args_dict["app_bridges"]:
             args_dict["bridges"].append(comm_client)
+
             def _exit(signum, frame):
                 comm_client.stop()
                 sys.exit(0)
@@ -437,16 +483,13 @@ def main():
                 resource_visualization.start()
             except OSError as e:
                 if "AMENT_PREFIX_PATH" in str(e):
-                    print_status(
-                        f"ROS 2环境未正确设置，跳过3D可视化启动。错误详情: {e}",
-                        "warning"
-                    )
+                    print_status(f"ROS 2环境未正确设置，跳过3D可视化启动。错误详情: {e}", "warning")
                     print_status(
                         "建议解决方案：\n"
                         "1. 激活Conda环境: conda activate unilab\n"
                         "2. 或使用 --backend simple 参数\n"
                         "3. 或使用 --visual disable 参数禁用可视化",
-                        "info"
+                        "info",
                     )
                 else:
                     raise

unilabos/app/web/client.py

@@ -76,7 +76,8 @@ class HTTPClient:
             Dict[str, str]: 旧UUID到新UUID的映射关系 {old_uuid: new_uuid}
         """
         with open(os.path.join(BasicConfig.working_dir, "req_resource_tree_add.json"), "w", encoding="utf-8") as f:
-            f.write(json.dumps({"nodes": [x for xs in resources.dump() for x in xs], "mount_uuid": mount_uuid}, indent=4))
+            payload = {"nodes": [x for xs in resources.dump() for x in xs], "mount_uuid": mount_uuid}
+            f.write(json.dumps(payload, indent=4))
         # 从序列化数据中提取所有节点的UUID（保存旧UUID）
         old_uuids = {n.res_content.uuid: n for n in resources.all_nodes}
         if not self.initialized or first_add:
@@ -335,6 +336,67 @@ class HTTPClient:
                 logger.error(f"响应内容: {response.text}")
         return None
 
+    def workflow_import(
+        self,
+        name: str,
+        workflow_uuid: str,
+        workflow_name: str,
+        nodes: List[Dict[str, Any]],
+        edges: List[Dict[str, Any]],
+        tags: Optional[List[str]] = None,
+        published: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        导入工作流到服务器
+
+        Args:
+            name: 工作流名称（顶层）
+            workflow_uuid: 工作流UUID
+            workflow_name: 工作流名称（data内部）
+            nodes: 工作流节点列表
+            edges: 工作流边列表
+            tags: 工作流标签列表，默认为空列表
+            published: 是否发布工作流，默认为False
+
+        Returns:
+            Dict: API响应数据，包含 code 和 data (uuid, name)
+        """
+        # target_lab_uuid 暂时使用默认值，后续由后端根据 ak/sk 获取
+        payload = {
+            "target_lab_uuid": "28c38bb0-63f6-4352-b0d8-b5b8eb1766d5",
+            "name": name,
+            "data": {
+                "workflow_uuid": workflow_uuid,
+                "workflow_name": workflow_name,
+                "nodes": nodes,
+                "edges": edges,
+                "tags": tags if tags is not None else [],
+                "published": published,
+            },
+        }
+        # 保存请求到文件
+        with open(os.path.join(BasicConfig.working_dir, "req_workflow_upload.json"), "w", encoding="utf-8") as f:
+            f.write(json.dumps(payload, indent=4, ensure_ascii=False))
+
+        response = requests.post(
+            f"{self.remote_addr}/lab/workflow/owner/import",
+            json=payload,
+            headers={"Authorization": f"Lab {self.auth}"},
+            timeout=60,
+        )
+        # 保存响应到文件
+        with open(os.path.join(BasicConfig.working_dir, "res_workflow_upload.json"), "w", encoding="utf-8") as f:
+            f.write(f"{response.status_code}" + "\n" + response.text)
+
+        if response.status_code == 200:
+            res = response.json()
+            if "code" in res and res["code"] != 0:
+                logger.error(f"导入工作流失败: {response.text}")
+            return res
+        else:
+            logger.error(f"导入工作流失败: {response.status_code}, {response.text}")
+            return {"code": response.status_code, "message": response.text}
+
 
 # 创建默认客户端实例
 http_client = HTTPClient()

unilabos/app/ws_client.py

@@ -438,7 +438,7 @@ class MessageProcessor:
                     self.connected = True
                     self.reconnect_count = 0
 
-                    logger.info(f"[MessageProcessor] Connected to {self.websocket_url}")
+                    logger.trace(f"[MessageProcessor] Connected to {self.websocket_url}")
 
                     # 启动发送协程
                     send_task = asyncio.create_task(self._send_handler())
@@ -503,7 +503,7 @@ class MessageProcessor:
 
     async def _send_handler(self):
         """处理发送队列中的消息"""
-        logger.debug("[MessageProcessor] Send handler started")
+        logger.trace("[MessageProcessor] Send handler started")
 
         try:
             while self.connected and self.websocket:
@@ -579,8 +579,6 @@ class MessageProcessor:
             elif message_type == "session_id":
                 self.session_id = message_data.get("session_id")
                 logger.info(f"[MessageProcessor] Session ID: {self.session_id}")
-            elif message_type == "request_reload":
-                await self._handle_request_reload(message_data)
             else:
                 logger.debug(f"[MessageProcessor] Unknown message type: {message_type}")
 
@@ -890,20 +888,6 @@ class MessageProcessor:
             )
             thread.start()
 
-    async def _handle_request_reload(self, data: Dict[str, Any]):
-        """
-        处理重载请求
-        
-        当LabGo发送request_reload时，重新发送设备注册信息
-        """
-        reason = data.get("reason", "unknown")
-        logger.info(f"[MessageProcessor] Received reload request, reason: {reason}")
-        
-        # 重新发送host_node_ready信息
-        if self.websocket_client:
-            self.websocket_client.publish_host_ready()
-            logger.info("[MessageProcessor] Re-sent host_node_ready after reload request")
-
     async def _send_action_state_response(
         self, device_id: str, action_name: str, task_id: str, job_id: str, typ: str, free: bool, need_more: int
     ):
@@ -981,7 +965,7 @@ class QueueProcessor:
 
     def _run(self):
         """运行队列处理主循环"""
-        logger.debug("[QueueProcessor] Queue processor started")
+        logger.trace("[QueueProcessor] Queue processor started")
 
         while self.is_running:
             try:
@@ -1191,7 +1175,6 @@ class WebSocketClient(BaseCommunicationClient):
         else:
             url = f"{scheme}://{parsed.netloc}/api/v1/ws/schedule"
 
-        logger.debug(f"[WebSocketClient] URL: {url}")
         return url
 
     def start(self) -> None:
@@ -1204,13 +1187,11 @@ class WebSocketClient(BaseCommunicationClient):
             logger.error("[WebSocketClient] WebSocket URL not configured")
             return
 
-        logger.info(f"[WebSocketClient] Starting connection to {self.websocket_url}")
-
         # 启动两个核心线程
         self.message_processor.start()
         self.queue_processor.start()
 
-        logger.info("[WebSocketClient] All threads started")
+        logger.trace("[WebSocketClient] All threads started")
 
     def stop(self) -> None:
         """停止WebSocket客户端"""
@@ -1301,7 +1282,7 @@ class WebSocketClient(BaseCommunicationClient):
         self.message_processor.send_message(message)
 
         job_log = format_job_log(item.job_id, item.task_id, item.device_id, item.action_name)
-        logger.trace(f"[WebSocketClient] Job status published: {job_log} - {status}")
+        logger.debug(f"[WebSocketClient] Job status published: {job_log} - {status}")
 
     def send_ping(self, ping_id: str, timestamp: float) -> None:
         """发送ping消息"""
@@ -1332,55 +1313,17 @@ class WebSocketClient(BaseCommunicationClient):
             logger.warning(f"[WebSocketClient] Failed to cancel job {job_log}")
 
     def publish_host_ready(self) -> None:
-        """发布host_node ready信号，包含设备和动作信息"""
+        """发布host_node ready信号"""
         if self.is_disabled or not self.is_connected():
             logger.debug("[WebSocketClient] Not connected, cannot publish host ready signal")
             return
 
-        # 收集设备信息
-        devices = []
-        machine_name = BasicConfig.machine_name
-        
-        try:
-            host_node = HostNode.get_instance(0)
-            if host_node:
-                # 获取设备信息
-                for device_id, namespace in host_node.devices_names.items():
-                    device_key = f"{namespace}/{device_id}" if namespace.startswith("/") else f"/{namespace}/{device_id}"
-                    is_online = device_key in host_node._online_devices
-                    
-                    # 获取设备的动作信息
-                    actions = {}
-                    for action_id, client in host_node._action_clients.items():
-                        # action_id 格式: /namespace/device_id/action_name
-                        if device_id in action_id:
-                            action_name = action_id.split("/")[-1]
-                            actions[action_name] = {
-                                "action_path": action_id,
-                                "action_type": str(type(client).__name__),
-                            }
-                    
-                    devices.append({
-                        "device_id": device_id,
-                        "namespace": namespace,
-                        "device_key": device_key,
-                        "is_online": is_online,
-                        "machine_name": host_node.device_machine_names.get(device_id, machine_name),
-                        "actions": actions,
-                    })
-                
-                logger.info(f"[WebSocketClient] Collected {len(devices)} devices for host_ready")
-        except Exception as e:
-            logger.warning(f"[WebSocketClient] Error collecting device info: {e}")
-
         message = {
             "action": "host_node_ready",
             "data": {
                 "status": "ready",
                 "timestamp": time.time(),
-                "machine_name": machine_name,
-                "devices": devices,
             },
         }
         self.message_processor.send_message(message)
-        logger.info(f"[WebSocketClient] Host node ready signal published with {len(devices)} devices")
+        logger.info("[WebSocketClient] Host node ready signal published")

unilabos/config/config.py

@@ -21,7 +21,8 @@ class BasicConfig:
     startup_json_path = None  # 填写绝对路径
     disable_browser = False  # 禁止浏览器自动打开
     port = 8002  # 本地HTTP服务
-    log_level: Literal['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'] = "DEBUG"  # 'TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'
+    # 'TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'
+    log_level: Literal["TRACE", "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "DEBUG"
 
     @classmethod
     def auth_secret(cls):
@@ -65,13 +66,14 @@ def _update_config_from_module(module):
                     if not attr.startswith("_"):
                         setattr(obj, attr, getattr(getattr(module, name), attr))
 
+
 def _update_config_from_env():
     prefix = "UNILABOS_"
     for env_key, env_value in os.environ.items():
         if not env_key.startswith(prefix):
             continue
         try:
-            key_path = env_key[len(prefix):]  # Remove UNILAB_ prefix
+            key_path = env_key[len(prefix) :]  # Remove UNILAB_ prefix
             class_field = key_path.upper().split("_", 1)
             if len(class_field) != 2:
                 logger.warning(f"[ENV] 环境变量格式不正确：{env_key}")

unilabos/devices/LICENSE

@@ -1,73 +0,0 @@
-Uni-Lab-OS软件许可使用准则
-
-
-本软件使用准则（以下简称"本准则"）旨在规范用户在使用Uni-Lab-OS软件（以下简称"本软件"）过程中的行为和义务。在下载、安装、使用或以任何方式访问本软件之前，请务必仔细阅读并理解以下条款和条件。若您不同意本准则的全部或部分内容，请您立即停止使用本软件。一旦您开始访问、下载、安装、使用本软件，即表示您已阅读、理解并同意接受本准则的约束。
-
-1、使用许可
-1.1 本软件的所有权及版权归北京深势科技有限公司（以下简称"深势科技"）所有。在遵守本准则的前提下，深势科技特此授予学术用户（以下简称"您"）一个全球范围内的、非排他性的、免版权费用的使用许可，可为了满足学术目的而使用本软件。
-
-1.2 本准则下授予的许可仅适用于本软件的二进制代码版本。您不对本软件源代码拥有任何权利。
-
-2、使用限制
-2.1 本准则仅授予学术用户出于学术目的使用本软件，任何商业组织、商业机构或其他非学术用户不得使用本软件，如果违反本条款，深势科技将保留一切追诉的权利。
-2.2 您将本软件用于任何商业行为，应取得深势科技的商业许可。
-2.3 您不得将本软件或任何形式的衍生作品用于任何商业目的，也不得将其出售、出租、转让、分发或以其他方式提供给任何第三方。您必须确保本软件的使用仅限于您个人学术研究，禁止您为任何其他实体的利益使用本软件（无论是否收费）。
-2.4 您不得以任何方式修改、破解、反编译、反汇编、反向工程、隔离、分离或以其他方式从任何程序或文档中提取源代码或试图发现本软件的源代码。您不得以任何方式去除、修改或屏蔽本软件中的任何版权、商标或其他专有权利声明。您不得使用本软件进行任何非法活动，包括但不限于侵犯他人的知识产权、隐私权等。
-2.5 您同意将本软件仅用于合法的学术目的，且遵守您所在国家或地区的法律法规，您将承担因违反法律法规而产生的一切法律责任。
-
-3、软件所有权
-本软件在此仅作使用许可，并非出售。本软件及与软件有关的全部文档的所有权及其他所有权利（包括但不限于知识产权和商业秘密），始终是深势科技的专有财产，您不拥有任何权利，但本准则下被明确授予的有限的使用许可权利除外。
-
-4、衍生作品传播规范
-若您传播基于Uni-Lab-OS程序修改形成的作品，须同时满足以下全部条件：
-4.1 作品必须包含显著声明，明确标注修改内容及修改日期；
-4.2 作品必须声明本作品依据本许可协议发布；
-4.3 必须将整个作品（包括修改部分）作为整体授予获取副本者本许可协议的保障，且该许可将自动延伸适用于作品全组件（无论其以何种形式打包）；
-4.4 若衍生作品含交互式用户界面：每个界面均须显示合规法律声明，若原始Uni-Lab-OS程序的交互界面未展示法律声明，您的衍生作品可免除此义务。
-
-5、提出建议
-您可以对本软件提出建议，前提是：
-（i）您声明并保证，该建议未侵害任何第三方的任何知识产权；
-（ii）您承认，深势科技有权使用该建议，但无使用该建议的义务；
-（iii）您授予深势科技一项非独占的、不可撤销的、可分许可的、无版权费的、全球范围的著作权许可，以复制、分发、传播、公开展示、公开表演、修改、翻译、基于其制作衍生作品、生产、制作、推销、销售、提供销售和/或以其他方式整体或部分地使用该建议和基于其的衍生作品，包括但不限于，通过将该建议整体或部分地纳入深势科技的软件和/或其他软件，以及在现存的或将来任何时候存在的任何媒介中或通过该媒介体现，以及为从事上述活动而授予多个分许可；
-（iv）您特此授予深势科技一项永久的、全球范围的、非独占性的、免费的、免特许权使用费的、不可撤销的专利许可，许可其制造、委托制造、使用、要约销售、销售、进口及以其他方式转让该建议和基于其的衍生专利。上述专利许可的适用范围仅限于以下专利权利要求：您有权许可的、且仅因您的建议本身，或因您的建议与所提交的本软件结合而必然构成侵权的专利权利要求。若任何实体针对您或其他实体提起专利诉讼（包括诉讼中的交叉诉讼或反诉），主张该建议或您所贡献的软件构成直接或间接专利侵权，则依据本协议授予的、针对该建议或软件的任何专利许可，自该诉讼提起之日起终止。
-（v）您放弃对该建议的任何权利或主张，深势科技无需承担任何义务、版税或基于知识产权或其他方面的限制。
-
-6、引用要求
-如您使用本软件获得的成果发表在出版物上，您应在成果中承认对Uni-Lab-OS软件的使用并标注权利人名称。引用 Uni-Lab-OS时请使用以下内容：
-@article{gao2025unilabos,
-	title = {UniLabOS: An AI-Native Operating System for Autonomous Laboratories},
-	doi = {10.48550/arXiv.2512.21766},
-	publisher = {arXiv},
-	author = {Gao, Jing and Chang, Junhan and Que, Haohui and Xiong, Yanfei and Zhang, Shixiang and Qi, Xianwei and Liu, Zhen and Wang, Jun-Jie and Ding, Qianjun and Li, Xinyu and Pan, Ziwei and Xie, Qiming and Yan, Zhuang and Yan, Junchi and Zhang, Linfeng},
-	year = {2025}
-}
-
-7、保留权利
-您认可，所有未被明确授予您的本软件的权利，无论是当前或今后存在的，均由深势科技予以保留，任何未经深势科技明确授权而使用本软件的行为将被视为侵权，深势科技有权追究侵权者的一切法律责任。
-
-8、保密信息
-您同意将本软件代码及相关文档视为深势科技的机密信息，您不会向任何第三方提供相关代码，并将采取合理审慎的使用态度来防止本软件代码及相关文档被泄露。
-
-9、无保证
-该软件是"按原样"提供的，没有任何明示或暗示的保证，不包含任何代码或规范没有缺陷、适销性、适用于特定目的或不侵犯第三方权利的保证。您同意您自主承担使用本软件或与本准则有关的全部风险。
-
-10、免责条款 
-在任何情况下，无论基于侵权（包括过失）、合同或其他法律理论，除非适用法律强制规定（如故意或重大过失行为）或另有书面协议，深势科技不对被许可人因软件许可、使用或无法使用软件所致损害承担责任（包括任何性质的直接、间接、特殊、偶发或后果性损害，例如但不限于商誉损失、停工损失、计算机故障或失灵造成的损害，以及其他一切商业损害或损失），即使深势科技已被告知发生此类损害的可能性亦不例外。
-被许可人在再分发软件或其衍生作品时，仅能以自身名义独立承担责任进行操作，不得代表深势科技或其他被许可人。
-
-11、终止
-如果您以任何方式违反本准则或未能遵守本准则的任何重要条款或条件，则您被授予的所有权利将自动终止。
-
-12、举报
-如果您认为有人违反了本准则，请向深势科技进行举报，深势科技将对您的身份进行严格保密，举报邮箱changjh@dp.tech。
-
-13、法律管辖
-本准则中的任何内容均不得解释为通过暗示、禁止反悔或其他方式授予本准则中授予的许可或权利以外的任何许可或权利。如果本准则的任何条款被认定为不可执行，则仅在必要的范围内对该条款进行修改，使其可执行。本准则应受中华人民共和国法律管辖，不适用法律冲突条款及《联合国国际货物销售合同公约》，因本准则产生的一切争议由北京市海淀区人民法院管辖。
-
-14、未来版本
-深势科技保留不经事先通知随时变更或停止本软件或本准则的权利。
-
-15、语言优先
-本准则同时具有中文版本和英文版本，如果英文版本和中文版本有冲突，以中文版本为准。
-

unilabos/devices/LICENSE_eng

@@ -1,73 +0,0 @@
-Uni-Lab-OS License Agreement
-
-Preamble
-This License Agreement (the "Agreement") is instituted to govern user conduct and obligations in relation to the utilization of the Uni-Lab-OS (the "Software"). By accessing, downloading, installing, or utilizing the Software in any manner, you hereby acknowledge that you have meticulously reviewed, comprehended, and consented to be legally bound by the terms herein. If you dissent from any provision of this Agreement, you must forthwith cease all interaction with the Software.
-
-1. Grant of License
-1.1 The proprietary rights to the Software are exclusively retained by Beijing DP Technology Co., Ltd. ("DP Technology"). Subject to full compliance with this Agreement, DP Technology hereby grants academic users ("Licensee") a worldwide, non-exclusive, royalty-free license to untilise the Software solely for non-commercial academic pursuits.
-
-1.2 The foregoing license applies exclusively to the Software's executable binary code. No rights whatsoever are conferred to the Software's source code.
-
-2. Usage Restrictions
-2.1 This license is restricted to academic users engaging in scholastic activities. Commercial entities, institutions, or any non-academic parties are expressly prohibited from utilizing the Software. Violations of this clause shall entitle DP Technology to pursue all available legal remedies.
-2.2 The Licensee shall obtain a commercial license from DP Technology for any commercial use of the Software.
-2.3 The Licensee shall not utilise the Software or any derivative works for commercial purposes, nor distribute, sublicense, lease, transfer, or otherwise disseminate the Software to third parties. The Licensee is strictly prohibited from utilizing the Software for the benefit of any third-party entity, whether gratuitously or otherwise.
-2.4 Reverse engineering, decompilation, disassembly, code isolation, or any attempt to derive source code from the Software is strictly prohibited. The Licensee shall not alter, circumvent, or remove copyright notices, trademarks, or proprietary legends embedded in the Software. Use of the Software for unlawful activities—including but not limited to intellectual property infringement or privacy violations—is categorically barred.
-2.5 The Licensee warrants that the Software shall be utilised solely for lawful academic purposes in compliance with applicable jurisdictional statutes. All legal liabilities arising from noncompliance shall be borne exclusively by the Licensee.
-
-3. Proprietary Rights
-This Agreement confers a license to utilise the Software, not a transfer of ownership. All intellectual property rights—including copyrights, patents, trade secrets, and documentation—remain the exclusive dominion of DP Technology. The Licensee acquires no entitlements beyond the limited usage privileges expressly delineated herein.
-
-4. Derivative Work
-You may convey a work based on the Software, or the modifications to produce it from the Software, provided that you meet all of these conditions:
-4.1 The work must carry prominent notices stating that you modified it, and giving a relevant date.
-4.2 The work must carry prominent notices stating that it is released under this License.
-4.3 You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.
-4.4 If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Software has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.
-
-5. Feedback and Proposals
-Licensees may submit proposals, suggestions, or improvements pertaining to the Software ("Feedback") under the following conditions:
-(a) Licensee represents and warrants that such Feedback does not infringe upon any third-party intellectual property rights;
-(b) Licensee acknowledges that DP Technology reserves the right, but assumes no obligation, to utilize such Feedback;
-(c) Licensee irrevocably grants DP Technology a non-exclusive, royalty-free, perpetual, worldwide, sublicensable copyright license to reproduce, distribute, modify, publicly perform or display, translate, create derivative works of, commercialize, and otherwise exploit the Feedback in any medium or format, whether now known or hereafter devised, including the right to grant multiple tiers of sublicenses to enable such activities;
-(d) Licensee hereby grants DP Technology a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Feedback and such Derivative Works, where such license applies only to those patent claimss licensable by Licensee that are necessarily infringed by the Feedback(s) alone or by comibination of the Feedback(s) with the Software to which such Feedback(s) were submitted. If any entity institutes patent litigation against Licensee or any other entity (including a cross-claim orcounterclaim in a lawsuit) alleging that the Feedback, or the Software to which you have contributed, constitutes direct or contributory patent infringement, then any patent licenses granted under this Agreement for the Feedback or Software shall terminate as of the date such litigation is filed.
-(e) Licensee hereby waives all claims, proprietary rights, or restrictions related to DP Technology's use of such Feedback.
-
-6. Citation Requirement
-If academic or research output generated using the Software is published, Licensee must explicitly acknowledge the use of Uni-Lab-OS and attribute ownership to DP Technology. The following citation must be included:
-@article{gao2025unilabos,
-	title = {UniLabOS: An AI-Native Operating System for Autonomous Laboratories},
-	doi = {10.48550/arXiv.2512.21766},
-	publisher = {arXiv},
-	author = {Gao, Jing and Chang, Junhan and Que, Haohui and Xiong, Yanfei and Zhang, Shixiang and Qi, Xianwei and Liu, Zhen and Wang, Jun-Jie and Ding, Qianjun and Li, Xinyu and Pan, Ziwei and Xie, Qiming and Yan, Zhuang and Yan, Junchi and Zhang, Linfeng},
-	year = {2025}
-}
-
-7. Reservation of Rights
-All rights not expressly granted herein, whether existing now or arising in the future, are exclusively reserved by DP Technology. Any unauthorized use of the Software beyond the scope of this Agreement constitutes infringement, and DP Technology reserves all legal rights to pursue remedies against violators.
-
-8. Confidentiality
-Licensee agrees to treat the Software's code, documentation, and related materials as confidential information. Licensee shall not disclose such materials to third parties and shall employ reasonable safeguards to prevent unauthorized access, dissemination, or misuse.
-
-9. Disclaimer of Warranties
-The software is provided "as is," without warranties of any kind, express or implied, including but not limited to warranties of merchantability, fitness for a particular purpose, non-infringement, or error-free operation. Licensee accepts all risks associated with the use of the software.
-
-10. Limitation of Liability
-In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall DP Technology be liable to Licensee for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the software (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if DP Technology has been advised of the possibility of such damages.
-While redistributing the Software or Derivative Works thereof, Licensee may act only on Licensee's own behalf and on Licensee's sole responsibility, not on behalf of DP Technology or any other Licensee.
-
-11. Termination
-All rights granted herein shall terminate immediately and automatically if Licensee materially breaches any provision of this Agreement.
-
-12. Reporting Violations
-To report suspected violations of this Agreement, notify DP Technology via the designated email address: changjh@dp.tech. DP Technology shall maintain the confidentiality of the reporter's identity.
-
-13. Governing Law and Dispute Resolution
-This Agreement shall be governed by the laws of the People's Republic of China, excluding its conflict of laws principles and the United Nations Convention on Contracts for the International Sale of Goods. Any dispute arising from this Agreement shall be exclusively adjudicated by the Haidian District People's Court in Beijing.
-
-14. Amendments and Updates
-DP Technology reserves the right to modify, suspend, or terminate the Software or this Agreement at any time without prior notice.
-
-15. Language Priority
-This Agreement is provided in both Chinese and English. In the event of any discrepancy, the Chinese version shall prevail.
-

unilabos/devices/liquid_handling/liquid_handler_abstract.py

@@ -207,7 +207,14 @@ class LiquidHandlerMiddleware(LiquidHandler):
 
         res_samples = []
         res_volumes = []
-        for resource, volume, channel in zip(resources, vols, use_channels):
+        # 处理 use_channels 为 None 的情况（通常用于单通道操作）
+        if use_channels is None:
+            # 对于单通道操作，推断通道为 [0]
+            channels_to_use = [0] * len(resources)
+        else:
+            channels_to_use = use_channels
+
+        for resource, volume, channel in zip(resources, vols, channels_to_use):
             res_samples.append({"name": resource.name, "sample_uuid": resource.unilabos_extra.get("sample_uuid", None)})
             res_volumes.append(volume)
             self.pending_liquids_dict[channel] = {
@@ -920,6 +927,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                                 offsets=offsets if offsets else None,
                                 height_to_bottom=mix_liquid_height if mix_liquid_height else None,
                                 mix_rate=mix_rate if mix_rate else None,
+                                use_channels=use_channels,
                             )
                         if delays is not None and len(delays) > 1:
                             await self.custom_delay(seconds=delays[1])
@@ -983,6 +991,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                                 offsets=offsets if offsets else None,
                                 height_to_bottom=mix_liquid_height if mix_liquid_height else None,
                                 mix_rate=mix_rate if mix_rate else None,
+                                use_channels=use_channels,
                             )
                         if delays is not None and len(delays) > 1:
                             await self.custom_delay(seconds=delays[1])
@@ -1165,6 +1174,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                         offsets=offsets if offsets else None,
                         height_to_bottom=mix_liquid_height if mix_liquid_height else None,
                         mix_rate=mix_rate if mix_rate else None,
+                        use_channels=use_channels,
                     )
 
                 await self.aspirate(
@@ -1199,6 +1209,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                         offsets=offsets if offsets else None,
                         height_to_bottom=mix_liquid_height if mix_liquid_height else None,
                         mix_rate=mix_rate if mix_rate else None,
+                        use_channels=use_channels,
                     )
                 if delays is not None and len(delays) > 1:
                     await self.custom_delay(seconds=delays[1])
@@ -1235,6 +1246,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                         offsets=offsets if offsets else None,
                         height_to_bottom=mix_liquid_height if mix_liquid_height else None,
                         mix_rate=mix_rate if mix_rate else None,
+                        use_channels=use_channels,
                     )
 
                 await self.aspirate(
@@ -1271,6 +1283,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                         offsets=offsets if offsets else None,
                         height_to_bottom=mix_liquid_height if mix_liquid_height else None,
                         mix_rate=mix_rate if mix_rate else None,
+                        use_channels=use_channels,
                     )
                 if delays is not None and len(delays) > 1:
                     await self.custom_delay(seconds=delays[1])
@@ -1327,6 +1340,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                         offsets=offsets[idx:idx + 1] if offsets and len(offsets) > idx else None,
                         height_to_bottom=mix_liquid_height if mix_liquid_height else None,
                         mix_rate=mix_rate if mix_rate else None,
+                        use_channels=use_channels,
                     )
 
             # 从源容器吸液（总体积）
@@ -1366,6 +1380,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                         offsets=offsets[idx:idx+1] if offsets else None,
                         height_to_bottom=mix_liquid_height if mix_liquid_height else None,
                         mix_rate=mix_rate if mix_rate else None,
+                        use_channels=use_channels,
                     )
                 if touch_tip:
                     await self.touch_tip([target])
@@ -1401,6 +1416,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                         offsets=offsets[i:i + 8] if offsets else None,
                         height_to_bottom=mix_liquid_height if mix_liquid_height else None,
                         mix_rate=mix_rate if mix_rate else None,
+                        use_channels=use_channels,
                     )
                 
                 # 从源容器吸液（8个通道都从同一个源，但每个通道的吸液体积不同）
@@ -1446,6 +1462,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                         offsets=offsets if offsets else None,
                         height_to_bottom=mix_liquid_height if mix_liquid_height else None,
                         mix_rate=mix_rate if mix_rate else None,
+                        use_channels=use_channels,
                     )
                 
                 if touch_tip:
@@ -1497,10 +1514,19 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                 f"(matching `asp_vols`). Got length {len(dis_vols)}."
             )
 
+        need_mix_after = mix_stage in ["after", "both"] and mix_times is not None and mix_times > 0
+        defer_final_discard = need_mix_after or touch_tip
+
         if len(use_channels) == 1:
             # 单通道模式：多次吸液，一次分液
-            # 先混合前（如果需要）
+
+            # 如果需要 before mix，先 pick up tip 并执行 mix
             if mix_stage in ["before", "both"] and mix_times is not None and mix_times > 0:
+                tip = []
+                for _ in range(len(use_channels)):
+                    tip.extend(next(self.current_tip))
+                await self.pick_up_tips(tip)
+
                 await self.mix(
                     targets=[target],
                     mix_time=mix_times,
@@ -1508,8 +1534,11 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                     offsets=offsets[0:1] if offsets else None,
                     height_to_bottom=mix_liquid_height if mix_liquid_height else None,
                     mix_rate=mix_rate if mix_rate else None,
+                    use_channels=use_channels,
                 )
-            
+
+                await self.discard_tips(use_channels=use_channels)
+
             # 从每个源容器吸液并分液到目标容器
             for idx, source in enumerate(sources):
                 tip = []
@@ -1527,10 +1556,10 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                     blow_out_air_volume=[blow_out_air_volume[idx]] if blow_out_air_volume and len(blow_out_air_volume) > idx else None,
                     spread=spread,
                 )
-                
+
                 if delays is not None:
                     await self.custom_delay(seconds=delays[0])
-                
+
                 # 分液到目标容器
                 if use_proportional_mixing:
                     # 按不同比例混合：使用对应的 dis_vols
@@ -1546,7 +1575,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                     dis_offset = offsets[0] if offsets and len(offsets) > 0 else None
                     dis_liquid_height = liquid_height[0] if liquid_height and len(liquid_height) > 0 else None
                     dis_blow_out = blow_out_air_volume[0] if blow_out_air_volume and len(blow_out_air_volume) > 0 else None
-                
+
                 await self.dispense(
                     resources=[target],
                     vols=[dis_vol],
@@ -1557,14 +1586,15 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                     liquid_height=[dis_liquid_height] if dis_liquid_height is not None else None,
                     spread=spread,
                 )
-                
+
                 if delays is not None and len(delays) > 1:
                     await self.custom_delay(seconds=delays[1])
-                
-                await self.discard_tips(use_channels=use_channels)
-            
+
+                if not (defer_final_discard and idx == len(sources) - 1):
+                    await self.discard_tips(use_channels=use_channels)
+
             # 最后在目标容器中混合（如果需要）
-            if mix_stage in ["after", "both"] and mix_times is not None and mix_times > 0:
+            if need_mix_after:
                 await self.mix(
                     targets=[target],
                     mix_time=mix_times,
@@ -1572,18 +1602,27 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                     offsets=offsets[0:1] if offsets else None,
                     height_to_bottom=mix_liquid_height if mix_liquid_height else None,
                     mix_rate=mix_rate if mix_rate else None,
+                    use_channels=use_channels,
                 )
             
             if touch_tip:
                 await self.touch_tip([target])
+
+            if defer_final_discard:
+                await self.discard_tips(use_channels=use_channels)
         
         elif len(use_channels) == 8:
             # 8通道模式：需要确保源数量是8的倍数
             if len(sources) % 8 != 0:
                 raise ValueError(f"For 8-channel mode, number of sources {len(sources)} must be a multiple of 8.")
-            
-            # 每次处理8个源
+
+            # 如果需要 before mix，先 pick up tips 并执行 mix
             if mix_stage in ["before", "both"] and mix_times is not None and mix_times > 0:
+                tip = []
+                for _ in range(len(use_channels)):
+                    tip.extend(next(self.current_tip))
+                await self.pick_up_tips(tip)
+
                 await self.mix(
                     targets=[target],
                     mix_time=mix_times,
@@ -1591,8 +1630,11 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                     offsets=offsets[0:1] if offsets else None,
                     height_to_bottom=mix_liquid_height if mix_liquid_height else None,
                     mix_rate=mix_rate if mix_rate else None,
+                    use_channels=use_channels,
                 )
 
+                await self.discard_tips([0,1,2,3,4,5,6,7])
+
             for i in range(0, len(sources), 8):
                 tip = []
                 for _ in range(len(use_channels)):
@@ -1650,11 +1692,12 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                 
                 if delays is not None and len(delays) > 1:
                     await self.custom_delay(seconds=delays[1])
-                
-                await self.discard_tips([0,1,2,3,4,5,6,7])
-            
+
+                if not (defer_final_discard and i + 8 >= len(sources)):
+                    await self.discard_tips([0,1,2,3,4,5,6,7])
+
             # 最后在目标容器中混合（如果需要）
-            if mix_stage in ["after", "both"] and mix_times is not None and mix_times > 0:
+            if need_mix_after:
                 await self.mix(
                     targets=[target],
                     mix_time=mix_times,
@@ -1662,11 +1705,15 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                     offsets=offsets[0:1] if offsets else None,
                     height_to_bottom=mix_liquid_height if mix_liquid_height else None,
                     mix_rate=mix_rate if mix_rate else None,
+                    use_channels=use_channels,
                 )
             
             if touch_tip:
                 await self.touch_tip([target])
 
+            if defer_final_discard:
+                await self.discard_tips([0,1,2,3,4,5,6,7])
+
     # except Exception as e:
     #     traceback.print_exc()
     #     raise RuntimeError(f"Liquid addition failed: {e}") from e
@@ -1686,7 +1733,12 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                 print(f"Waiting time: {msg}")
                 print(f"Current time: {time.strftime('%H:%M:%S')}")
                 print(f"Time to finish: {time.strftime('%H:%M:%S', time.localtime(time.time() + seconds))}")
-            await self._ros_node.sleep(seconds)
+            # Use ROS node sleep if available, otherwise use asyncio.sleep
+            if hasattr(self, '_ros_node') and self._ros_node is not None:
+                await self._ros_node.sleep(seconds)
+            else:
+                import asyncio
+                await asyncio.sleep(seconds)
             if msg:
                 print(f"Done: {msg}")
                 print(f"Current time: {time.strftime('%H:%M:%S')}")
@@ -1725,27 +1777,59 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
         height_to_bottom: Optional[float] = None,
         offsets: Optional[Coordinate] = None,
         mix_rate: Optional[float] = None,
+        use_channels: Optional[List[int]] = None,
         none_keys: List[str] = [],
     ):
-        if mix_time is None:  # No mixing required
+        if mix_time is None or mix_time <= 0:  # No mixing required
             return
         """Mix the liquid in the target wells."""
+        if mix_vol is None:
+            raise ValueError("`mix_vol` must be provided when `mix_time` is set.")
+
+        targets_list: List[Container] = list(targets)
+        if len(targets_list) == 0:
+            return
+
+        def _expand(value, count: int):
+            if value is None:
+                return [None] * count
+            if isinstance(value, (list, tuple)):
+                if len(value) != count:
+                    raise ValueError("Length of per-target parameters must match targets.")
+                return list(value)
+            return [value] * count
+
+        offsets_list = _expand(offsets, len(targets_list))
+        heights_list = _expand(height_to_bottom, len(targets_list))
+        rates_list = _expand(mix_rate, len(targets_list))
+
         for _ in range(mix_time):
-            await self.aspirate(
-                resources=[targets],
-                vols=[mix_vol],
-                flow_rates=[mix_rate] if mix_rate else None,
-                offsets=[offsets] if offsets else None,
-                liquid_height=[height_to_bottom] if height_to_bottom else None,
-            )
-            await self.custom_delay(seconds=1)
-            await self.dispense(
-                resources=[targets],
-                vols=[mix_vol],
-                flow_rates=[mix_rate] if mix_rate else None,
-                offsets=[offsets] if offsets else None,
-                liquid_height=[height_to_bottom] if height_to_bottom else None,
-            )
+            for idx, target in enumerate(targets_list):
+                offset_arg = (
+                    [offsets_list[idx]] if offsets_list[idx] is not None else None
+                )
+                height_arg = (
+                    [heights_list[idx]] if heights_list[idx] is not None else None
+                )
+                rate_arg = [rates_list[idx]] if rates_list[idx] is not None else None
+
+                await self.aspirate(
+                    resources=[target],
+                    vols=[mix_vol],
+                    use_channels=use_channels,
+                    flow_rates=rate_arg,
+                    offsets=offset_arg,
+                    liquid_height=height_arg,
+                )
+                await self.custom_delay(seconds=1)
+                await self.dispense(
+                    resources=[target],
+                    vols=[mix_vol],
+                    use_channels=use_channels,
+                    flow_rates=rate_arg,
+                    offsets=offset_arg,
+                    liquid_height=height_arg,
+                )
 
     def iter_tips(self, tip_racks: Sequence[TipRack]) -> Iterator[Resource]:
         """Yield tips from a list of TipRacks one-by-one until depleted."""

unilabos/devices/liquid_handling/prcxi/prcxi.py

@@ -30,10 +30,11 @@ from pylabrobot.liquid_handling.standard import (
     ResourceMove,
     ResourceDrop,
 )
-from pylabrobot.resources import ResourceHolder, ResourceStack, Tip, Deck, Plate, Well, TipRack, Resource, Container, Coordinate, TipSpot, Trash, PlateAdapter, TubeRack
+from pylabrobot.resources import ResourceHolder, ResourceStack, Tip, Deck, Plate, Well, TipRack, Resource, Container, Coordinate, TipSpot, Trash, PlateAdapter, TubeRack, create_homogeneous_resources, create_ordered_items_2d
 
 from unilabos.devices.liquid_handling.liquid_handler_abstract import LiquidHandlerAbstract, SimpleReturn
-from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
+from unilabos.resources.itemized_carrier import ItemizedCarrier
+from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode, ROS2DeviceNode
 
 
 class PRCXIError(RuntimeError):
@@ -70,16 +71,7 @@ class PRCXI9300Deck(Deck):
 
     def __init__(self, name: str, size_x: float, size_y: float, size_z: float, **kwargs):
         super().__init__(name, size_x, size_y, size_z)
-        self.slots = [None] * 16  # PRCXI 9300/9320 最大有 16 个槽位
-        self.slot_locations = [Coordinate(0, 0, 0)] * 16
-
-    def assign_child_at_slot(self, resource: Resource, slot: int, reassign: bool = False) -> None:
-        if self.slots[slot - 1] is not None and not reassign:
-            raise ValueError(f"Spot {slot} is already occupied")
-
-        self.slots[slot - 1] = resource
-        super().assign_child_resource(resource, location=self.slot_locations[slot - 1])
-
+        self.slots = [None] * 6  # PRCXI 9300 有 6 个槽位
 class PRCXI9300Container(Plate):
     """PRCXI 9300 的专用 Container 类，继承自 Plate，用于槽位定位和未知模块。
 
@@ -95,19 +87,81 @@ class PRCXI9300Container(Plate):
         category: str,
         ordering: collections.OrderedDict,
         model: Optional[str] = None,
+        material_info: Optional[Dict[str, Any]] = None,
+        ordering_layout: str = "col-major",
         **kwargs,
     ):
         super().__init__(name, size_x, size_y, size_z, category=category, ordering=ordering, model=model)
         self._unilabos_state = {}
+        self.sites = kwargs.get("sites", [])
+        self.sites = create_homogeneous_resources(
+            klass=ResourceHolder,
+            locations=[Coordinate(0, 0, 0)],
+            resource_size_x=size_x,
+            resource_size_y=size_y,
+            resource_size_z=size_z,
+            name_prefix=name,
+        )[0]
+        # 为 ItemizedCarrier 添加 _unilabos_state 属性，以便与其他 PRCXI 组件兼容
+        sites_resource = ItemizedCarrier(
+            name=name+"_sites",
+            sites={name: self.sites},
+            size_x=size_x,
+            size_y=size_y,
+            size_z=size_z,
+            category="warehouse",
+            model=model,
+        )
+        sites_resource._unilabos_state = {}  # 添加 _unilabos_state 属性
+        if material_info:
+            sites_resource._unilabos_state["Material"] = material_info
+
+        self.assign_child_resource(sites_resource, location=self.sites.location)
+
+        # 保存排序方式，供graphio.py的坐标映射使用
+        # 使用独立属性避免与父类的layout冲突
+        self.ordering_layout = ordering_layout
+
+    def serialize(self) -> dict:
+        """序列化时保存 ordering_layout 属性"""
+        data = super().serialize()
+        data['ordering_layout'] = self.ordering_layout
+        return data
 
     def load_state(self, state: Dict[str, Any]) -> None:
         """从给定的状态加载工作台信息。"""
         super().load_state(state)
         self._unilabos_state = state
 
+    def get_site(self) -> ResourceHolder:
+        """获取容器的站点"""
+        return self.sites
+
+    def add_resource_to_site(self, resource) -> None:
+        """向站点添加资源"""
+        self.sites.assign_child_resource(resource)
+
+    def get_resource_at_site(self):
+        """获取站点上的资源"""
+        return self.sites.children[0] if self.sites.children else None
+
     def serialize_state(self) -> Dict[str, Dict[str, Any]]:
         data = super().serialize_state()
         data.update(self._unilabos_state)
+
+        # 避免序列化 ResourceHolder 对象
+        if hasattr(self, 'sites') and self.sites:
+            # 创建 sites 的可序列化版本
+            if hasattr(self.sites, '__class__') and 'pylabrobot' in str(self.sites.__class__.__module__):
+                data['sites'] = {
+                    "__pylabrobot_object__": True,
+                    "class": self.sites.__class__.__name__,
+                    "module": self.sites.__class__.__module__,
+                    "name": getattr(self.sites, 'name', str(self.sites))
+                }
+            else:
+                data['sites'] = self.sites
+
         return data   
 class PRCXI9300Plate(Plate):
     """ 
@@ -136,13 +190,31 @@ class PRCXI9300Plate(Plate):
                 # 使用 ordering 参数，只包含位置信息（键）
                 ordering_param = collections.OrderedDict((k, None) for k in ordering.keys())
             else:
-                # ordering 的值已经是对象，可以直接使用
-                items = ordering
-                ordering_param = None
+                # ordering 的值是对象（可能是 Well 对象），检查是否有有效的 location
+                # 如果是反序列化过程，Well 对象可能没有正确的 location，需要让 Plate 重新创建
+                sample_value = next(iter(ordering.values()), None)
+                if sample_value is not None and hasattr(sample_value, 'location'):
+                    # 如果是 Well 对象但 location 为 None，说明是反序列化过程
+                    # 让 Plate 自己创建 Well 对象
+                    if sample_value.location is None:
+                        items = None
+                        ordering_param = collections.OrderedDict((k, None) for k in ordering.keys())
+                    else:
+                        # Well 对象有有效的 location，可以直接使用
+                        items = ordering
+                        ordering_param = None
+                elif sample_value is None:
+                    # ordering 的值都是 None，让 Plate 自己创建 Well 对象
+                    items = None
+                    ordering_param = collections.OrderedDict((k, None) for k in ordering.keys())
+                else:
+                    # 其他情况，直接使用
+                    items = ordering
+                    ordering_param = None
         else:
             items = None
-            ordering_param = None
-        
+            ordering_param = collections.OrderedDict()  # 提供空的 ordering
+
         # 根据情况传递不同的参数
         if items is not None:
             super().__init__(name, size_x, size_y, size_z, 
@@ -219,9 +291,16 @@ class PRCXI9300TipRack(TipRack):
                 # 使用 ordering 参数，只包含位置信息（键）
                 ordering_param = collections.OrderedDict((k, None) for k in ordering.keys())
             else:
-                # ordering 的值已经是对象，可以直接使用
-                items = ordering
-                ordering_param = None
+                # ordering 的值已经是对象，需要过滤掉 None 值
+                # 只保留有效的对象，用于 ordered_items 参数
+                valid_items = {k: v for k, v in ordering.items() if v is not None}
+                if valid_items:
+                    items = valid_items
+                    ordering_param = None
+                else:
+                    # 如果没有有效对象，使用 ordering 参数
+                    items = None
+                    ordering_param = collections.OrderedDict((k, None) for k in ordering.keys())
         else:
             items = None
             ordering_param = None
@@ -284,7 +363,7 @@ class PRCXI9300Trash(Trash):
     """
 
     def __init__(self, name: str, size_x: float, size_y: float, size_z: float, 
-                 category: str = "trash", 
+                 category: str = "plate", 
                  material_info: Optional[Dict[str, Any]] = None,
                  **kwargs):
         
@@ -357,9 +436,16 @@ class PRCXI9300TubeRack(TubeRack):
                 # 使用 ordering 参数，只包含位置信息（键）
                 ordering_param = collections.OrderedDict((k, None) for k in ordering.keys())
             else:
-                # ordering 的值已经是对象，可以直接使用
-                items_to_pass = ordering
-                ordering_param = None
+                # ordering 的值已经是对象，需要过滤掉 None 值
+                # 只保留有效的对象，用于 ordered_items 参数
+                valid_items = {k: v for k, v in ordering.items() if v is not None}
+                if valid_items:
+                    items_to_pass = valid_items
+                    ordering_param = None
+                else:
+                    # 如果没有有效对象，使用 ordering 参数
+                    items_to_pass = None
+                    ordering_param = collections.OrderedDict((k, None) for k in ordering.keys())
         elif items is not None:
             # 兼容旧的 items 参数
             items_to_pass = items
@@ -415,6 +501,81 @@ class PRCXI9300TubeRack(TubeRack):
             
             data.update(safe_state)
         return data
+class PRCXI9300PlateAdapterSite(ItemizedCarrier):
+    def __init__(self, name: str, size_x: float, size_y: float, size_z: float,
+                 material_info: Optional[Dict[str, Any]] = None, **kwargs):
+        # 处理 sites 参数的不同格式
+
+        sites = create_homogeneous_resources(
+        klass=ResourceHolder,
+        locations=[Coordinate(0, 0, 0)],
+        resource_size_x=size_x,
+        resource_size_y=size_y,
+        resource_size_z=size_z,
+        name_prefix=name,
+    )[0]
+        # 确保不传递重复的参数
+        kwargs.pop('layout', None)
+        kwargs.pop('num_items_x', None)
+        kwargs.pop('num_items_y', None)
+        kwargs.pop('num_items_z', None)
+        kwargs.pop('sites', None)
+
+        super().__init__(name, size_x, size_y, size_z,
+        sites={name: sites},
+        num_items_x=1,
+        num_items_y=1,
+        num_items_z=1,
+        **kwargs)
+        self._unilabos_state = {}
+        if material_info:
+            self._unilabos_state["Material"] = material_info
+
+
+    def assign_child_resource(self, resource, location=Coordinate(0, 0, 0), reassign=True, spot=None):
+        """重写 assign_child_resource 方法，对于适配器位置，不使用索引分配"""
+        # 直接调用 Resource 的 assign_child_resource，避免 ItemizedCarrier 的索引逻辑
+        from pylabrobot.resources.resource import Resource
+        Resource.assign_child_resource(self, resource, location=location, reassign=reassign)
+
+    def unassign_child_resource(self, resource):
+        """重写 unassign_child_resource 方法，对于适配器位置，不使用 sites 列表"""
+        # 直接调用 Resource 的 unassign_child_resource，避免 ItemizedCarrier 的 sites 逻辑
+        from pylabrobot.resources.resource import Resource
+        Resource.unassign_child_resource(self, resource)
+
+    def serialize_state(self) -> Dict[str, Dict[str, Any]]:
+        try:
+            data = super().serialize_state()
+        except AttributeError:
+            data = {}
+
+        # 包含 sites 配置信息，但避免序列化 ResourceHolder 对象
+        if hasattr(self, 'sites') and self.sites:
+            # 只保存 sites 的基本信息，不保存 ResourceHolder 对象本身
+            sites_info = []
+            for site in self.sites:
+                if hasattr(site, '__class__') and 'pylabrobot' in str(site.__class__.__module__):
+                    # 对于 pylabrobot 对象，只保存基本信息
+                    sites_info.append({
+                        "__pylabrobot_object__": True,
+                        "class": site.__class__.__name__,
+                        "module": site.__class__.__module__,
+                        "name": getattr(site, 'name', str(site))
+                    })
+                else:
+                    sites_info.append(site)
+            data['sites'] = sites_info
+
+        return data
+
+    def load_state(self, state: Dict[str, Any]) -> None:
+        """加载状态，包括 sites 配置信息"""
+        super().load_state(state)
+
+        # 从状态中恢复 sites 配置信息
+        if 'sites' in state:
+            self.sites = [state['sites']]
 
 class PRCXI9300PlateAdapter(PlateAdapter):
     """
@@ -813,7 +974,7 @@ class PRCXI9300Handler(LiquidHandlerAbstract):
         **backend_kwargs,
     ):
 
-        return await super().move_plate(
+        res = await super().move_plate(
             plate,
             to,
             intermediate_locations,
@@ -825,6 +986,12 @@ class PRCXI9300Handler(LiquidHandlerAbstract):
             target_plate_number = to,
             **backend_kwargs,
         )
+        plate.unassign()
+        to.assign_child_resource(plate, location=Coordinate(0, 0, 0))
+        ROS2DeviceNode.run_async_func(self._ros_node.update_resource, True, **{
+            "resources": [self.deck]
+        })
+        return res
 
 class PRCXI9300Backend(LiquidHandlerBackend):
     """PRCXI 9300 的后端实现，继承自 LiquidHandlerBackend。

unilabos/registry/devices/liquid_handler.yaml

@@ -4019,7 +4019,8 @@ liquid_handler:
           mix_liquid_height: 0.0
           mix_rate: 0
           mix_stage: ''
-          mix_times: 0
+          mix_times:
+          - 0
           mix_vol: 0
           none_keys:
           - ''
@@ -4175,9 +4176,11 @@ liquid_handler:
                 mix_stage:
                   type: string
                 mix_times:
-                  maximum: 2147483647
-                  minimum: -2147483648
-                  type: integer
+                  items:
+                    maximum: 2147483647
+                    minimum: -2147483648
+                    type: integer
+                  type: array
                 mix_vol:
                   maximum: 2147483647
                   minimum: -2147483648
@@ -5040,7 +5043,8 @@ liquid_handler.biomek:
           mix_liquid_height: 0.0
           mix_rate: 0
           mix_stage: ''
-          mix_times: 0
+          mix_times:
+          - 0
           mix_vol: 0
           none_keys:
           - ''
@@ -5183,9 +5187,11 @@ liquid_handler.biomek:
                 mix_stage:
                   type: string
                 mix_times:
-                  maximum: 2147483647
-                  minimum: -2147483648
-                  type: integer
+                  items:
+                    maximum: 2147483647
+                    minimum: -2147483648
+                    type: integer
+                  type: array
                 mix_vol:
                   maximum: 2147483647
                   minimum: -2147483648
@@ -9665,7 +9671,8 @@ liquid_handler.prcxi:
           mix_liquid_height: 0.0
           mix_rate: 0
           mix_stage: ''
-          mix_times: 0
+          mix_times:
+          - 0
           mix_vol: 0
           none_keys:
           - ''
@@ -9737,7 +9744,34 @@ liquid_handler.prcxi:
           touch_tip: false
           use_channels:
           - 0
-        handles: {}
+        handles:
+          input:
+          - data_key: liquid
+            data_source: handle
+            data_type: resource
+            handler_key: sources
+            label: sources
+          - data_key: liquid
+            data_source: executor
+            data_type: resource
+            handler_key: targets
+            label: targets
+          - data_key: liquid
+            data_source: executor
+            data_type: resource
+            handler_key: tip_rack
+            label: tip_rack
+          output:
+          - data_key: liquid
+            data_source: handle
+            data_type: resource
+            handler_key: sources_out
+            label: sources
+          - data_key: liquid
+            data_source: executor
+            data_type: resource
+            handler_key: targets_out
+            label: targets
         placeholder_keys:
           sources: unilabos_resources
           targets: unilabos_resources
@@ -9794,9 +9828,11 @@ liquid_handler.prcxi:
                 mix_stage:
                   type: string
                 mix_times:
-                  maximum: 2147483647
-                  minimum: -2147483648
-                  type: integer
+                  items:
+                    maximum: 2147483647
+                    minimum: -2147483648
+                    type: integer
+                  type: array
                 mix_vol:
                   maximum: 2147483647
                   minimum: -2147483648

unilabos/registry/registry.py

@@ -222,7 +222,7 @@ class Registry:
         abs_path = Path(path).absolute()
         resource_path = abs_path / "resources"
         files = list(resource_path.glob("*/*.yaml"))
-        logger.debug(f"[UniLab Registry] resources: {resource_path.exists()}, total: {len(files)}")
+        logger.trace(f"[UniLab Registry] load resources? {resource_path.exists()}, total: {len(files)}")
         current_resource_number = len(self.resource_type_registry) + 1
         for i, file in enumerate(files):
             with open(file, encoding="utf-8", mode="r") as f:

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
@@ -134,7 +134,7 @@ def canonicalize_nodes_data(
             parent_instance.children.append(current_instance)
 
     # 第五步：创建 ResourceTreeSet
-    resource_tree_set = ResourceTreeSet.from_nested_instance_list(standardized_instances)
+    resource_tree_set = ResourceTreeSet.from_nested_list(standardized_instances)
     return resource_tree_set
 
 

unilabos/ros/nodes/base_device_node.py

@@ -5,8 +5,7 @@ import json
 import threading
 import time
 import traceback
-from typing import get_type_hints, TypeVar, Generic, Dict, Any, Type, TypedDict, Optional, List, TYPE_CHECKING, Union, \
-    Tuple
+from typing import get_type_hints, TypeVar, Generic, Dict, Any, Type, TypedDict, Optional, List, TYPE_CHECKING, Union
 
 from concurrent.futures import ThreadPoolExecutor
 import asyncio
@@ -363,82 +362,78 @@ class BaseROS2DeviceNode(Node, Generic[T]):
             return res
 
         async def append_resource(req: SerialCommand_Request, res: SerialCommand_Response):
-            from pylabrobot.resources.resource import Resource as ResourcePLR
-            from pylabrobot.resources.deck import Deck
-            from pylabrobot.resources import Coordinate
-            from pylabrobot.resources import Plate
             # 物料传输到对应的node节点
-            client = self._resource_clients["c2s_update_resource_tree"]
-            request = SerialCommand.Request()
-            request2 = SerialCommand.Request()
+            rclient = self.create_client(ResourceAdd, "/resources/add")
+            rclient.wait_for_service()
+            rclient2 = self.create_client(ResourceAdd, "/resources/add")
+            rclient2.wait_for_service()
+            request = ResourceAdd.Request()
+            request2 = ResourceAdd.Request()
             command_json = json.loads(req.command)
             namespace = command_json["namespace"]
             bind_parent_id = command_json["bind_parent_id"]
             edge_device_id = command_json["edge_device_id"]
             location = command_json["bind_location"]
             other_calling_param = command_json["other_calling_param"]
-            input_resources = command_json["resource"]
+            resources = command_json["resource"]
             initialize_full = other_calling_param.pop("initialize_full", False)
             # 用来增加液体
             ADD_LIQUID_TYPE = other_calling_param.pop("ADD_LIQUID_TYPE", [])
-            LIQUID_VOLUME: List[float] = other_calling_param.pop("LIQUID_VOLUME", [])
-            LIQUID_INPUT_SLOT: List[int] = other_calling_param.pop("LIQUID_INPUT_SLOT", [])
+            LIQUID_VOLUME = other_calling_param.pop("LIQUID_VOLUME", [])
+            LIQUID_INPUT_SLOT = other_calling_param.pop("LIQUID_INPUT_SLOT", [])
             slot = other_calling_param.pop("slot", "-1")
-            if slot != -1:  # slot为负数的时候采用assign方法
+            resource = None
+            if slot != "-1":  # slot为负数的时候采用assign方法
                 other_calling_param["slot"] = slot
-            # 本地拿到这个物料，可能需要先做初始化
-            if isinstance(input_resources, list) and initialize_full:
-                input_resources = initialize_resources(input_resources)
-            elif initialize_full:
-                input_resources = initialize_resources([input_resources])
-            rts: ResourceTreeSet = ResourceTreeSet.from_raw_dict_list(input_resources)
-            parent_resource = None
-            if bind_parent_id != self.node_name:
-                parent_resource = self.resource_tracker.figure_resource(
-                    {"name": bind_parent_id}
-                )
-            for r in rts.root_nodes:
-                # noinspection PyUnresolvedReferences
-                r.res_content.parent_uuid = parent_resource.unilabos_uuid
-
-            if len(LIQUID_INPUT_SLOT) and LIQUID_INPUT_SLOT[0] == -1 and len(rts.root_nodes) == 1 and isinstance(rts.root_nodes[0], RegularContainer):
-                # noinspection PyTypeChecker
-                container_instance: RegularContainer = rts.root_nodes[0]
+            # 本地拿到这个物料，可能需要先做初始化?
+            if isinstance(resources, list):
+                if (
+                    len(resources) == 1 and isinstance(resources[0], list) and not initialize_full
+                ):  # 取消，不存在的情况
+                    # 预先initialize过，以整组的形式传入
+                    request.resources = [convert_to_ros_msg(Resource, resource_) for resource_ in resources[0]]
+                elif initialize_full:
+                    resources = initialize_resources(resources)
+                    request.resources = [convert_to_ros_msg(Resource, resource) for resource in resources]
+                else:
+                    request.resources = [convert_to_ros_msg(Resource, resource) for resource in resources]
+            else:
+                if initialize_full:
+                    resources = initialize_resources([resources])
+                request.resources = [convert_to_ros_msg(Resource, resources)]
+            if len(LIQUID_INPUT_SLOT) and LIQUID_INPUT_SLOT[0] == -1:
+                container_instance = request.resources[0]
+                container_query_dict: dict = resources
                 found_resources = self.resource_tracker.figure_resource(
-                    {"id": container_instance.name}, try_mode=True
+                    {"id": container_query_dict["name"]}, try_mode=True
                 )
                 if not len(found_resources):
                     self.resource_tracker.add_resource(container_instance)
-                    logger.info(f"添加物料{container_instance.name}到资源跟踪器")
+                    logger.info(f"添加物料{container_query_dict['name']}到资源跟踪器")
                 else:
                     assert (
                         len(found_resources) == 1
-                    ), f"找到多个同名物料: {container_instance.name}, 请检查物料系统"
-                    found_resource = found_resources[0]
-                    if isinstance(found_resource, RegularContainer):
-                        logger.info(f"更新物料{container_instance.name}的数据{found_resource.state}")
-                        found_resource.state.update(json.loads(container_instance.state))
-                    elif isinstance(found_resource, dict):
-                        raise ValueError("已不支持 字典 版本的RegularContainer")
+                    ), f"找到多个同名物料: {container_query_dict['name']}, 请检查物料系统"
+                    resource = found_resources[0]
+                    if isinstance(resource, Resource):
+                        regular_container = RegularContainer(resource.id)
+                        regular_container.ulr_resource = resource
+                        regular_container.ulr_resource_data.update(json.loads(container_instance.data))
+                        logger.info(f"更新物料{container_query_dict['name']}的数据{resource.data} ULR")
+                    elif isinstance(resource, dict):
+                        if "data" not in resource:
+                            resource["data"] = {}
+                        resource["data"].update(json.loads(container_instance.data))
+                        request.resources[0].name = resource["name"]
+                        logger.info(f"更新物料{container_query_dict['name']}的数据{resource['data']} dict")
                     else:
                         logger.info(
-                            f"更新物料{container_instance.name}出现不支持的数据类型{type(found_resource)} {found_resource}"
+                            f"更新物料{container_query_dict['name']}出现不支持的数据类型{type(resource)} {resource}"
                         )
-            # noinspection PyUnresolvedReferences
-            request.command = json.dumps({
-                "action": "add",
-                "data": {
-                    "data": rts.dump(),
-                    "mount_uuid": parent_resource.unilabos_uuid if parent_resource is not None else "",
-                    "first_add": False,
-                },
-            })
-            tree_response: SerialCommand.Response = await client.call_async(request)
-            uuid_maps = json.loads(tree_response.response)
-            self.resource_tracker.loop_update_uuid(input_resources, uuid_maps)
-            self.lab_logger().info(f"Resource tree added. UUID mapping: {len(uuid_maps)} nodes")
+            response: ResourceAdd.Response = await rclient.call_async(request)
+            # 应该先add_resource了
             final_response = {
-                "created_resources": rts.dump(),
+                "created_resources": [ROS2MessageInstance(i).get_python_dict() for i in request.resources],
                 "liquid_input_resources": [],
             }
             res.response = json.dumps(final_response)
@@ -463,63 +458,59 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                     )
                     res.response = get_result_info_str(traceback.format_exc(), False, {})
                 return res
+            # 接下来该根据bind_parent_id进行assign了，目前只有plr可以进行assign，不然没有办法输入到物料系统中
+            if bind_parent_id != self.node_name:
+                resource = self.resource_tracker.figure_resource(
+                    {"name": bind_parent_id}
+                )  # 拿到父节点，进行具体assign等操作
+            # request.resources = [convert_to_ros_msg(Resource, resources)]
+
             try:
-                if len(rts.root_nodes) == 1 and parent_resource is not None:
-                    plr_instance = rts.to_plr_resources()[0]
+                from pylabrobot.resources.resource import Resource as ResourcePLR
+                from pylabrobot.resources.deck import Deck
+                from pylabrobot.resources import Coordinate
+                from pylabrobot.resources import OTDeck
+                from pylabrobot.resources import Plate
+
+                contain_model = not isinstance(resource, Deck)
+                if isinstance(resource, ResourcePLR):
+                    # resources.list()
+                    plr_instance = ResourceTreeSet.from_raw_list(resources).to_plr_resources()[0]
+                    # resources_tree = dict_to_tree(copy.deepcopy({r["id"]: r for r in resources}))
+                    # plr_instance = resource_ulab_to_plr(resources_tree[0], contain_model)
+
                     if isinstance(plr_instance, Plate):
-                        empty_liquid_info_in: List[Tuple[Optional[str], float]] = [(None, 0)] * plr_instance.num_items
-                        if len(ADD_LIQUID_TYPE) == 1 and len(LIQUID_VOLUME) == 1 and len(LIQUID_INPUT_SLOT) > 1:
-                            ADD_LIQUID_TYPE = ADD_LIQUID_TYPE * len(LIQUID_INPUT_SLOT)
-                            LIQUID_VOLUME = LIQUID_VOLUME * len(LIQUID_INPUT_SLOT)
-                            self.lab_logger().warning(f"增加液体资源时，数量为1，自动补全为 {len(LIQUID_INPUT_SLOT)} 个")
+                        empty_liquid_info_in = [(None, 0)] * plr_instance.num_items
                         for liquid_type, liquid_volume, liquid_input_slot in zip(
                             ADD_LIQUID_TYPE, LIQUID_VOLUME, LIQUID_INPUT_SLOT
                         ):
                             empty_liquid_info_in[liquid_input_slot] = (liquid_type, liquid_volume)
                         plr_instance.set_well_liquids(empty_liquid_info_in)
-                        try:
-                            # noinspection PyProtectedMember
-                            keys = list(plr_instance._ordering.keys())
-                            for ind, r in enumerate(LIQUID_INPUT_SLOT[:]):
-                                if isinstance(r, int):
-                                    # noinspection PyTypeChecker
-                                    LIQUID_INPUT_SLOT[ind] = keys[r]
-                            input_wells = [plr_instance.get_well(r) for r in LIQUID_INPUT_SLOT]
-                        except AttributeError:
-                            # 按照id回去失败，回退到children
-                            input_wells = []
-                            for r in LIQUID_INPUT_SLOT:
-                                input_wells.append(plr_instance.children[r])
-                        final_response["liquid_input_resources"] = ResourceTreeSet.from_plr_resources(input_wells).dump()
+                        input_wells_ulr = [
+                            convert_to_ros_msg(
+                                Resource,
+                                resource_plr_to_ulab(plr_instance.get_well(LIQUID_INPUT_SLOT), with_children=False),
+                            )
+                            for r in LIQUID_INPUT_SLOT
+                        ]
+                        final_response["liquid_input_resources"] = [
+                            ROS2MessageInstance(i).get_python_dict() for i in input_wells_ulr
+                        ]
                         res.response = json.dumps(final_response)
-                    if issubclass(parent_resource.__class__, Deck) and hasattr(parent_resource, "assign_child_at_slot") and "slot" in other_calling_param:
+                    if isinstance(resource, OTDeck) and "slot" in other_calling_param:
                         other_calling_param["slot"] = int(other_calling_param["slot"])
-                        parent_resource.assign_child_at_slot(plr_instance, **other_calling_param)
+                        resource.assign_child_at_slot(plr_instance, **other_calling_param)
                     else:
-                        _discard_slot = other_calling_param.pop("slot", -1)
-                        parent_resource.assign_child_resource(
+                        _discard_slot = other_calling_param.pop("slot", "-1")
+                        resource.assign_child_resource(
                             plr_instance,
                             Coordinate(location["x"], location["y"], location["z"]),
                             **other_calling_param,
                         )
-                    # 调整了液体以及Deck之后要重新Assign
-                    # noinspection PyUnresolvedReferences
-                    rts_with_parent = ResourceTreeSet.from_plr_resources([parent_resource])
-                    if rts_with_parent.root_nodes[0].res_content.uuid_parent is None:
-                        rts_with_parent.root_nodes[0].res_content.parent_uuid = self.uuid
-                    request.command = json.dumps({
-                        "action": "add",
-                        "data": {
-                            "data": rts_with_parent.dump(),
-                            "mount_uuid": rts_with_parent.root_nodes[0].res_content.uuid_parent,
-                            "first_add": False,
-                        },
-                    })
-                    tree_response: SerialCommand.Response = await client.call_async(request)
-                    uuid_maps = json.loads(tree_response.response)
-                    self.resource_tracker.loop_update_uuid(input_resources, uuid_maps)
-                    self._lab_logger.info(f"Resource tree added. UUID mapping: {len(uuid_maps)} nodes")
-                    # 这里created_resources不包含parent_resource
+                    request2.resources = [
+                        convert_to_ros_msg(Resource, r) for r in tree_to_list([resource_plr_to_ulab(resource)])
+                    ]
+                    rclient2.call(request2)
                 # 发送给ResourceMeshManager
                 action_client = ActionClient(
                     self,
@@ -530,7 +521,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                 goal = SendCmd.Goal()
                 goal.command = json.dumps(
                     {
-                        "resources": input_resources,
+                        "resources": resources,
                         "bind_parent_id": bind_parent_id,
                     }
                 )
@@ -623,7 +614,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):
             )
         )  # type: ignore
         raw_nodes = json.loads(response.response)
-        tree_set = ResourceTreeSet.from_raw_dict_list(raw_nodes)
+        tree_set = ResourceTreeSet.from_raw_list(raw_nodes)
         self.lab_logger().debug(f"获取资源结果: {len(tree_set.trees)} 个资源树")
         return tree_set
 
@@ -651,7 +642,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):
         raw_data = json.loads(response.response)
 
         # 转换为 PLR 资源
-        tree_set = ResourceTreeSet.from_raw_dict_list(raw_data)
+        tree_set = ResourceTreeSet.from_raw_list(raw_data)
         plr_resource = tree_set.to_plr_resources()[0]
         self.lab_logger().debug(f"获取资源 {resource_id} 成功")
         return plr_resource
@@ -796,7 +787,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):
             }
 
         def _handle_update(
-            plr_resources: List[Union[ResourcePLR, ResourceDictInstance]], tree_set: ResourceTreeSet, additional_add_params: Dict[str, Any]
+            plr_resources: List[ResourcePLR], tree_set: ResourceTreeSet, additional_add_params: Dict[str, Any]
         ) -> Dict[str, Any]:
             """
             处理资源更新操作的内部函数
@@ -810,9 +801,6 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                 操作结果字典
             """
             for plr_resource, tree in zip(plr_resources, tree_set.trees):
-                if isinstance(plr_resource, ResourceDictInstance):
-                    self._lab_logger.info(f"跳过 非资源{plr_resource.res_content.name} 的更新")
-                    continue
                 states = plr_resource.serialize_all_state()
                 original_instance: ResourcePLR = self.resource_tracker.figure_resource(
                     {"uuid": tree.root_node.res_content.uuid}, try_mode=False
@@ -892,12 +880,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                     elif action == "update":
                         if tree_set is None:
                             raise ValueError("tree_set不能为None")
-                        plr_resources = []
-                        for tree in tree_set.trees:
-                            if tree.root_node.res_content.type == "device":
-                                plr_resources.append(tree.root_node)
-                            else:
-                                plr_resources.append(ResourceTreeSet([tree]).to_plr_resources()[0])
+                        plr_resources = tree_set.to_plr_resources()
                         result = _handle_update(plr_resources, tree_set, additional_add_params)
                         results.append(result)
                     elif action == "remove":
@@ -1540,7 +1523,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):
         raw_data = json.loads(response.response)
 
         # 转换为 PLR 资源
-        tree_set = ResourceTreeSet.from_raw_dict_list(raw_data)
+        tree_set = ResourceTreeSet.from_raw_list(raw_data)
         plr_resource = tree_set.to_plr_resources()[0]
 
         # 通过资源跟踪器获取本地实例

unilabos/ros/nodes/presets/host_node.py

@@ -45,7 +45,6 @@ from unilabos.ros.nodes.resource_tracker import (
 )
 from unilabos.utils import logger
 from unilabos.utils.exception import DeviceClassInvalid
-from unilabos.utils.log import warning
 from unilabos.utils.type_check import serialize_result_info
 from unilabos.registry.placeholder_type import ResourceSlot, DeviceSlot
 
@@ -181,7 +180,7 @@ class HostNode(BaseROS2DeviceNode):
                                 for plr_resource in ResourceTreeSet([tree]).to_plr_resources():
                                     self._resource_tracker.add_resource(plr_resource)
                             except Exception as ex:
-                                warning(f"[Host Node-Resource] 根节点物料{tree}序列化失败！")
+                                self.lab_logger().warning(f"[Host Node-Resource] 根节点物料{tree}序列化失败！")
         except Exception as ex:
             logger.error(f"[Host Node-Resource] 添加物料出错！\n{traceback.format_exc()}")
         # 初始化Node基类，传递空参数覆盖列表
@@ -456,10 +455,10 @@ class HostNode(BaseROS2DeviceNode):
 
     async def create_resource(
         self,
-        device_id: DeviceSlot,
+        device_id: str,
         res_id: str,
         class_name: str,
-        parent: ResourceSlot,
+        parent: str,
         bind_locations: Point,
         liquid_input_slot: list[int] = [],
         liquid_type: list[str] = [],
@@ -806,7 +805,7 @@ class HostNode(BaseROS2DeviceNode):
 
             self.lab_logger().info(f"[Host Node] Result for {action_id} ({job_id[:8]}): {status}")
             if goal_status != GoalStatus.STATUS_CANCELED:
-                self.lab_logger().trace(f"[Host Node] Result data: {result_data}")
+                self.lab_logger().debug(f"[Host Node] Result data: {result_data}")
 
             # 清理 _goals 中的记录
             if job_id in self._goals:
@@ -1168,11 +1167,12 @@ class HostNode(BaseROS2DeviceNode):
             响应对象，包含查询到的资源
         """
         try:
+            from unilabos.app.web import http_client
             data = json.loads(request.command)
             if "uuid" in data and data["uuid"] is not None:
-                http_req = self.bridges[-1].resource_tree_get([data["uuid"]], data["with_children"])
+                http_req = http_client.resource_tree_get([data["uuid"]], data["with_children"])
             elif "id" in data and data["id"].startswith("/"):
-                http_req = self.bridges[-1].resource_get(data["id"], data["with_children"])
+                http_req = http_client.resource_get(data["id"], data["with_children"])
             else:
                 raise ValueError("没有使用正确的物料 id 或 uuid")
             response.response = json.dumps(http_req["data"])

unilabos/ros/nodes/presets/workstation.py

@@ -244,7 +244,7 @@ class ROS2WorkstationNode(BaseROS2DeviceNode):
                                 r
                             )  # type: ignore
                             raw_data = json.loads(response.response)
-                            tree_set = ResourceTreeSet.from_raw_dict_list(raw_data)
+                            tree_set = ResourceTreeSet.from_raw_list(raw_data)
                             target = tree_set.dump()
                             protocol_kwargs[k] = target[0][0] if v == "unilabos_msgs/Resource" else target
                         except Exception as ex:

unilabos/ros/nodes/resource_tracker.py

@@ -66,8 +66,8 @@ class ResourceDict(BaseModel):
     klass: str = Field(alias="class", description="Resource class name")
     pose: ResourceDictPosition = Field(description="Resource position", default_factory=ResourceDictPosition)
     config: Dict[str, Any] = Field(description="Resource configuration")
-    data: Dict[str, Any] = Field(description="Resource data")
-    extra: Dict[str, Any] = Field(description="Extra data")
+    data: Dict[str, Any] = Field(description="Resource data, eg: container liquid data")
+    extra: Dict[str, Any] = Field(description="Extra data, eg: slot index")
 
     @field_serializer("parent_uuid")
     def _serialize_parent(self, parent_uuid: Optional["ResourceDict"]):
@@ -523,7 +523,7 @@ class ResourceTreeSet(object):
         return plr_resources
 
     @classmethod
-    def from_raw_dict_list(cls, raw_list: List[Dict[str, Any]]) -> "ResourceTreeSet":
+    def from_raw_list(cls, raw_list: List[Dict[str, Any]]) -> "ResourceTreeSet":
         """
         从原始字典列表创建 ResourceTreeSet，自动建立 parent-children 关系
 
@@ -573,10 +573,10 @@ class ResourceTreeSet(object):
                     parent_instance.children.append(instance)
 
         # 第四步：使用 from_nested_list 创建 ResourceTreeSet
-        return cls.from_nested_instance_list(instances)
+        return cls.from_nested_list(instances)
 
     @classmethod
-    def from_nested_instance_list(cls, nested_list: List[ResourceDictInstance]) -> "ResourceTreeSet":
+    def from_nested_list(cls, nested_list: List[ResourceDictInstance]) -> "ResourceTreeSet":
         """
         从扁平化的资源列表创建ResourceTreeSet，自动按根节点分组
 
@@ -785,7 +785,7 @@ class ResourceTreeSet(object):
         """
         nested_lists = []
         for tree_data in data:
-            nested_lists.extend(ResourceTreeSet.from_raw_dict_list(tree_data).trees)
+            nested_lists.extend(ResourceTreeSet.from_raw_list(tree_data).trees)
         return cls(nested_lists)
 
 
@@ -965,7 +965,7 @@ class DeviceNodeResourceTracker(object):
                     if current_uuid in self.uuid_to_resources:
                         self.uuid_to_resources.pop(current_uuid)
                     self.uuid_to_resources[new_uuid] = res
-                    logger.trace(f"更新uuid: {current_uuid} -> {new_uuid}")
+                    logger.debug(f"更新uuid: {current_uuid} -> {new_uuid}")
                     replaced = 1
             return replaced
 

unilabos/test/experiments/prcxi_9320_with_res_test.json

@@ -8,8 +8,8 @@
       "parent": "",
       "pose": {
         "size": {
-          "width": 562,
-          "height": 394,
+          "width": 542,
+          "height": 374,
           "depth": 0
         }
       },
@@ -21,12 +21,12 @@
         },
         "host": "10.20.30.184",
         "port": 9999,
-        "debug": true,
+        "debug": false,
         "setup": true,
         "is_9320": true,
         "timeout": 10,
         "matrix_id": "5de524d0-3f95-406c-86dd-f83626ebc7cb",
-        "simulator": true,
+        "simulator": false,
         "channel_num": 2
       },
       "data": {
@@ -37,7 +37,7 @@
       "model": null,
       "position": {
         "x": 0,
-        "y": 240,
+        "y": 700,
         "z": 0
       }
     },
@@ -50,8 +50,8 @@
       "type": "deck",
       "class": "",
       "position": {
-        "x": 10,
-        "y": 10,
+        "x": 0,
+        "y": 0,
         "z": 0
       },
       "config": {
@@ -83,7 +83,7 @@
         "z": 0
       },
       "config": {
-        "type": "PRCXI9300Container",
+        "type": "PRCXI9300PlateAdapterSite",
         "size_x": 127,
         "size_y": 85.5,
         "size_z": 10,
@@ -96,7 +96,7 @@
         "category": "plate",
         "model": null,
         "barcode": null,
-        "ordering": {},
+        
         "sites": [
           {
             "label": "T1",
@@ -128,7 +128,7 @@
         "z": 0
       },
       "config": {
-        "type": "PRCXI9300Container",
+        "type": "PRCXI9300PlateAdapterSite",
         "size_x": 127,
         "size_y": 85.5,
         "size_z": 10,
@@ -141,7 +141,7 @@
         "category": "plate",
         "model": null,
         "barcode": null,
-        "ordering": {},
+        
         "sites": [
           {
             "label": "T2",
@@ -173,7 +173,7 @@
         "z": 0
       },
       "config": {
-        "type": "PRCXI9300Container",
+        "type": "PRCXI9300PlateAdapterSite",
         "size_x": 127,
         "size_y": 85.5,
         "size_z": 10,
@@ -186,7 +186,7 @@
         "category": "plate",
         "model": null,
         "barcode": null,
-        "ordering": {},
+        
         "sites": [
           {
             "label": "T3",
@@ -218,7 +218,7 @@
         "z": 0
       },
       "config": {
-        "type": "PRCXI9300Container",
+        "type": "PRCXI9300PlateAdapterSite",
         "size_x": 127,
         "size_y": 85.5,
         "size_z": 10,
@@ -231,7 +231,7 @@
         "category": "plate",
         "model": null,
         "barcode": null,
-        "ordering": {},
+        
         "sites": [
           {
             "label": "T4",
@@ -263,7 +263,7 @@
         "z": 0
       },
       "config": {
-        "type": "PRCXI9300Container",
+        "type": "PRCXI9300PlateAdapterSite",
         "size_x": 127,
         "size_y": 85.5,
         "size_z": 10,
@@ -276,7 +276,7 @@
         "category": "plate",
         "model": null,
         "barcode": null,
-        "ordering": {},
+        
         "sites": [
           {
             "label": "T5",
@@ -308,7 +308,7 @@
         "z": 0
       },
       "config": {
-        "type": "PRCXI9300Container",
+        "type": "PRCXI9300PlateAdapterSite",
         "size_x": 127,
         "size_y": 85.5,
         "size_z": 10,
@@ -321,7 +321,7 @@
         "category": "plate",
         "model": null,
         "barcode": null,
-        "ordering": {},
+        
         "sites": [
           {
             "label": "T6",
@@ -353,7 +353,7 @@
         "z": 0
       },
       "config": {
-        "type": "PRCXI9300Container",
+        "type": "PRCXI9300PlateAdapterSite",
         "size_x": 127,
         "size_y": 85.5,
         "size_z": 10,
@@ -366,7 +366,7 @@
         "category": "plate",
         "model": null,
         "barcode": null,
-        "ordering": {},
+        
         "sites": [
           {
             "label": "T7",
@@ -398,7 +398,7 @@
         "z": 0
       },
       "config": {
-        "type": "PRCXI9300Container",
+        "type": "PRCXI9300PlateAdapterSite",
         "size_x": 127,
         "size_y": 85.5,
         "size_z": 10,
@@ -411,7 +411,7 @@
         "category": "plate",
         "model": null,
         "barcode": null,
-        "ordering": {},
+        
         "sites": [
           {
             "label": "T8",
@@ -443,7 +443,7 @@
         "z": 0
       },
       "config": {
-        "type": "PRCXI9300Container",
+        "type": "PRCXI9300PlateAdapterSite",
         "size_x": 127,
         "size_y": 85.5,
         "size_z": 10,
@@ -456,7 +456,7 @@
         "category": "plate",
         "model": null,
         "barcode": null,
-        "ordering": {},
+        
         "sites": [
           {
             "label": "T9",
@@ -488,7 +488,7 @@
         "z": 0
       },
       "config": {
-        "type": "PRCXI9300Container",
+        "type": "PRCXI9300PlateAdapterSite",
         "size_x": 127,
         "size_y": 85.5,
         "size_z": 10,
@@ -501,7 +501,7 @@
         "category": "plate",
         "model": null,
         "barcode": null,
-        "ordering": {},
+        
         "sites": [
           {
             "label": "T10",
@@ -533,7 +533,7 @@
         "z": 0
       },
       "config": {
-        "type": "PRCXI9300Container",
+        "type": "PRCXI9300PlateAdapterSite",
         "size_x": 127,
         "size_y": 85.5,
         "size_z": 10,
@@ -546,7 +546,7 @@
         "category": "plate",
         "model": null,
         "barcode": null,
-        "ordering": {},
+        
         "sites": [
           {
             "label": "T11",
@@ -578,7 +578,7 @@
         "z": 0
       },
       "config": {
-        "type": "PRCXI9300Container",
+        "type": "PRCXI9300PlateAdapterSite",
         "size_x": 127,
         "size_y": 85.5,
         "size_z": 10,
@@ -591,7 +591,7 @@
         "category": "plate",
         "model": null,
         "barcode": null,
-        "ordering": {},
+        
         "sites": [
           {
             "label": "T12",
@@ -623,7 +623,7 @@
         "z": 0
       },
       "config": {
-        "type": "PRCXI9300Container",
+        "type": "PRCXI9300PlateAdapterSite",
         "size_x": 127,
         "size_y": 85.5,
         "size_z": 10,
@@ -636,7 +636,7 @@
         "category": "plate",
         "model": null,
         "barcode": null,
-        "ordering": {},
+        
         "sites": [
           {
             "label": "T13",
@@ -668,7 +668,7 @@
         "z": 0
       },
       "config": {
-        "type": "PRCXI9300Container",
+        "type": "PRCXI9300PlateAdapterSite",
         "size_x": 127,
         "size_y": 85.5,
         "size_z": 10,
@@ -681,7 +681,7 @@
         "category": "plate",
         "model": null,
         "barcode": null,
-        "ordering": {},
+        
         "sites": [
           {
             "label": "T14",
@@ -713,7 +713,7 @@
         "z": 0
       },
       "config": {
-        "type": "PRCXI9300Container",
+        "type": "PRCXI9300PlateAdapterSite",
         "size_x": 127,
         "size_y": 85.5,
         "size_z": 10,
@@ -726,7 +726,7 @@
         "category": "plate",
         "model": null,
         "barcode": null,
-        "ordering": {},
+        
         "sites": [
           {
             "label": "T15",
@@ -758,7 +758,7 @@
         "z": 0
       },
       "config": {
-        "type": "PRCXI9300Container",
+        "type": "PRCXI9300PlateAdapterSite",
         "size_x": 127,
         "size_y": 85.5,
         "size_z": 10,
@@ -771,7 +771,7 @@
         "category": "plate",
         "model": null,
         "barcode": null,
-        "ordering": {},
+        
         "sites": [
           {
             "label": "T16",
@@ -40712,7 +40712,7 @@
 
       "children": [],
       "parent": "T16",
-      "type": "plate",
+      "type": "trash",
       "class": "",
       "position": {
         "x": 0,

unilabos/workflow/common.py

@@ -0,0 +1,547 @@
+import re
+import uuid
+
+import networkx as nx
+from networkx.drawing.nx_agraph import to_agraph
+import matplotlib.pyplot as plt
+from typing import Dict, List, Any, Tuple, Optional
+
+Json = Dict[str, Any]
+
+# ---------------- Graph ----------------
+
+
+class WorkflowGraph:
+    """简单的有向图实现：使用 params 单层参数；inputs 内含连线；支持 node-link 导出"""
+
+    def __init__(self):
+        self.nodes: Dict[str, Dict[str, Any]] = {}
+        self.edges: List[Dict[str, Any]] = []
+
+    def add_node(self, node_id: str, **attrs):
+        self.nodes[node_id] = attrs
+
+    def add_edge(self, source: str, target: str, **attrs):
+        # 将 source_port/target_port 映射为服务端期望的 source_handle_key/target_handle_key
+        source_handle_key = attrs.pop("source_port", "") or attrs.pop("source_handle_key", "")
+        target_handle_key = attrs.pop("target_port", "") or attrs.pop("target_handle_key", "")
+
+        edge = {
+            "source": source,
+            "target": target,
+            "source_node_uuid": source,
+            "target_node_uuid": target,
+            "source_handle_key": source_handle_key,
+            "source_handle_io": attrs.pop("source_handle_io", "source"),
+            "target_handle_key": target_handle_key,
+            "target_handle_io": attrs.pop("target_handle_io", "target"),
+            **attrs,
+        }
+        self.edges.append(edge)
+
+    def _materialize_wiring_into_inputs(
+        self,
+        obj: Any,
+        inputs: Dict[str, Any],
+        variable_sources: Dict[str, Dict[str, Any]],
+        target_node_id: str,
+        base_path: List[str],
+    ):
+        has_var = False
+
+        def walk(node: Any, path: List[str]):
+            nonlocal has_var
+            if isinstance(node, dict):
+                if "__var__" in node:
+                    has_var = True
+                    varname = node["__var__"]
+                    placeholder = f"${{{varname}}}"
+                    src = variable_sources.get(varname)
+                    if src:
+                        key = ".".join(path)  # e.g. "params.foo.bar.0"
+                        inputs[key] = {"node": src["node_id"], "output": src.get("output_name", "result")}
+                        self.add_edge(
+                            str(src["node_id"]),
+                            target_node_id,
+                            source_handle_io=src.get("output_name", "result"),
+                            target_handle_io=key,
+                        )
+                    return placeholder
+                return {k: walk(v, path + [k]) for k, v in node.items()}
+            if isinstance(node, list):
+                return [walk(v, path + [str(i)]) for i, v in enumerate(node)]
+            return node
+
+        replaced = walk(obj, base_path[:])
+        return replaced, has_var
+
+    def add_workflow_node(
+        self,
+        node_id: int,
+        *,
+        device_key: Optional[str] = None,  # 实例名，如 "ser"
+        resource_name: Optional[str] = None,  # registry key（原 device_class）
+        module: Optional[str] = None,
+        template_name: Optional[str] = None,  # 动作/模板名（原 action_key）
+        params: Dict[str, Any],
+        variable_sources: Dict[str, Dict[str, Any]],
+        add_ready_if_no_vars: bool = True,
+        prev_node_id: Optional[int] = None,
+        **extra_attrs,
+    ) -> None:
+        """添加工作流节点：params 单层；自动变量连线与 ready 串联；支持附加属性"""
+        node_id_str = str(node_id)
+        inputs: Dict[str, Any] = {}
+
+        params, has_var = self._materialize_wiring_into_inputs(
+            params, inputs, variable_sources, node_id_str, base_path=["params"]
+        )
+
+        if add_ready_if_no_vars and not has_var:
+            last_id = str(prev_node_id) if prev_node_id is not None else "-1"
+            inputs["ready"] = {"node": int(last_id), "output": "ready"}
+            self.add_edge(last_id, node_id_str, source_handle_io="ready", target_handle_io="ready")
+
+        node_obj = {
+            "device_key": device_key,
+            "resource_name": resource_name,  # ✅ 新名字
+            "module": module,
+            "template_name": template_name,  # ✅ 新名字
+            "params": params,
+            "inputs": inputs,
+        }
+        node_obj.update(extra_attrs or {})
+        self.add_node(node_id_str, parameters=node_obj)
+
+    # 顺序工作流导出（连线在 inputs，不返回 edges）
+    def to_dict(self) -> List[Dict[str, Any]]:
+        result = []
+        for node_id, attrs in self.nodes.items():
+            node = {"uuid": node_id}
+            params = dict(attrs.get("parameters", {}) or {})
+            flat = {k: v for k, v in attrs.items() if k != "parameters"}
+            flat.update(params)
+            node.update(flat)
+            result.append(node)
+        return sorted(result, key=lambda n: int(n["uuid"]) if str(n["uuid"]).isdigit() else n["uuid"])
+
+    # node-link 导出（含 edges）
+    def to_node_link_dict(self) -> Dict[str, Any]:
+        nodes_list = []
+        for node_id, attrs in self.nodes.items():
+            node_attrs = attrs.copy()
+            params = node_attrs.pop("parameters", {}) or {}
+            node_attrs.update(params)
+            nodes_list.append({"uuid": node_id, **node_attrs})
+        return {
+            "directed": True,
+            "multigraph": False,
+            "graph": {},
+            "nodes": nodes_list,
+            "edges": self.edges,
+            "links": self.edges,
+        }
+
+
+def refactor_data(
+    data: List[Dict[str, Any]],
+    action_resource_mapping: Optional[Dict[str, str]] = None,
+) -> List[Dict[str, Any]]:
+    """统一的数据重构函数，根据操作类型自动选择模板
+
+    Args:
+        data: 原始步骤数据列表
+        action_resource_mapping: action 到 resource_name 的映射字典，可选
+    """
+    refactored_data = []
+
+    # 定义操作映射，包含生物实验和有机化学的所有操作
+    OPERATION_MAPPING = {
+        # 生物实验操作
+        "transfer_liquid": "transfer_liquid",
+        "transfer": "transfer",
+        "incubation": "incubation",
+        "move_labware": "move_labware",
+        "oscillation": "oscillation",
+        # 有机化学操作
+        "HeatChillToTemp": "HeatChillProtocol",
+        "StopHeatChill": "HeatChillStopProtocol",
+        "StartHeatChill": "HeatChillStartProtocol",
+        "HeatChill": "HeatChillProtocol",
+        "Dissolve": "DissolveProtocol",
+        "Transfer": "TransferProtocol",
+        "Evaporate": "EvaporateProtocol",
+        "Recrystallize": "RecrystallizeProtocol",
+        "Filter": "FilterProtocol",
+        "Dry": "DryProtocol",
+        "Add": "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, action_resource_mapping)
+                refactored_data.extend(sub_data)
+            continue
+
+        # 获取模板名称
+        template_name = OPERATION_MAPPING.get(operation)
+        if not template_name:
+            # 自动推断模板类型
+            if operation.lower() in ["transfer", "incubation", "move_labware", "oscillation"]:
+                template_name = f"biomek-{operation}"
+            else:
+                template_name = f"{operation}Protocol"
+
+        # 获取 resource_name
+        resource_name = f"device.{operation.lower()}"
+        if action_resource_mapping:
+            resource_name = action_resource_mapping.get(operation, resource_name)
+
+        # 获取步骤编号，生成 name 字段
+        step_number = step.get("step_number")
+        name = f"Step {step_number}" if step_number is not None else None
+
+        # 创建步骤数据
+        step_data = {
+            "template_name": template_name,
+            "resource_name": resource_name,
+            "description": step.get("description", step.get("purpose", f"{operation} operation")),
+            "lab_node_type": "Device",
+            "param": step.get("parameters", step.get("action_args", {})),
+            "footer": f"{template_name}-{resource_name}",
+        }
+        if name:
+            step_data["name"] = name
+        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,
+    action_resource_mapping: Optional[Dict[str, str]] = None,
+) -> WorkflowGraph:
+    """统一的协议图构建函数，根据设备类型自动选择构建逻辑
+
+    Args:
+        labware_info: labware 信息字典
+        protocol_steps: 协议步骤列表
+        workstation_name: 工作站名称
+        action_resource_mapping: action 到 resource_name 的映射字典，可选
+    """
+    G = WorkflowGraph()
+    resource_last_writer = {}
+
+    protocol_steps = refactor_data(protocol_steps, action_resource_mapping)
+    # 有机化学&移液站协议图构建
+    WORKSTATION_ID = workstation_name
+
+    # 为所有labware创建资源节点
+    res_index = 0
+    for labware_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 "Rack" in str(labware_id) or "Tip" in str(labware_id):
+            lab_node_type = "Labware"
+            description = f"Prepare Labware: {labware_id}"
+            liquid_type = []
+            liquid_volume = []
+        elif item.get("type") == "hardware" or "reactor" in str(labware_id).lower():
+            if "reactor" not in str(labware_id).lower():
+                continue
+            lab_node_type = "Sample"
+            description = f"Prepare Reactor: {labware_id}"
+            liquid_type = []
+            liquid_volume = []
+        else:
+            lab_node_type = "Reagent"
+            description = f"Add Reagent to Flask: {labware_id}"
+            liquid_type = [labware_id]
+            liquid_volume = [1e5]
+
+        res_index += 1
+        G.add_node(
+            node_id,
+            template_name="create_resource",
+            resource_name="host_node",
+            name=f"Res {res_index}",
+            description=description,
+            lab_node_type=lab_node_type,
+            footer="create_resource-host_node",
+            param={
+                "res_id": labware_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": "",
+            },
+        )
+        resource_last_writer[labware_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("param", {})
+        input_resources_possible_names = [
+            "vessel",
+            "to_vessel",
+            "from_vessel",
+            "reagent",
+            "solvent",
+            "compound",
+            "sources",
+            "targets",
+        ]
+
+        for target_port in input_resources_possible_names:
+            resource_name = params.get(target_port)
+            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 = {
+            "vessel_out": params.get("vessel"),
+            "from_vessel_out": params.get("from_vessel"),
+            "to_vessel_out": params.get("to_vessel"),
+            "filtrate_out": 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: WorkflowGraph, 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_name", 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}'")
+
+
+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_name", 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_handle_key") or edge.get("source_port")
+        tp = edge.get("target_handle_key") or edge.get("target_port")
+
+        # 记录到图里（保留原始端口信息）
+        G.add_edge(u, v, source_handle_key=sp, target_handle_key=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}'")
+
+
+# ---------------- Registry Adapter ----------------
+
+
+class RegistryAdapter:
+    """根据 module 的类名（冒号右侧）反查 registry 的 resource_name（原 device_class），并抽取参数顺序"""
+
+    def __init__(self, device_registry: Dict[str, Any]):
+        self.device_registry = device_registry or {}
+        self.module_class_to_resource = self._build_module_class_index()
+
+    def _build_module_class_index(self) -> Dict[str, str]:
+        idx = {}
+        for resource_name, info in self.device_registry.items():
+            module = info.get("module")
+            if isinstance(module, str) and ":" in module:
+                cls = module.split(":")[-1]
+                idx[cls] = resource_name
+                idx[cls.lower()] = resource_name
+        return idx
+
+    def resolve_resource_by_classname(self, class_name: str) -> Optional[str]:
+        if not class_name:
+            return None
+        return self.module_class_to_resource.get(class_name) or self.module_class_to_resource.get(class_name.lower())
+
+    def get_device_module(self, resource_name: Optional[str]) -> Optional[str]:
+        if not resource_name:
+            return None
+        return self.device_registry.get(resource_name, {}).get("module")
+
+    def get_actions(self, resource_name: Optional[str]) -> Dict[str, Any]:
+        if not resource_name:
+            return {}
+        return (self.device_registry.get(resource_name, {}).get("class", {}).get("action_value_mappings", {})) or {}
+
+    def get_action_schema(self, resource_name: Optional[str], template_name: str) -> Optional[Json]:
+        return (self.get_actions(resource_name).get(template_name) or {}).get("schema")
+
+    def get_action_goal_default(self, resource_name: Optional[str], template_name: str) -> Json:
+        return (self.get_actions(resource_name).get(template_name) or {}).get("goal_default", {}) or {}
+
+    def get_action_input_keys(self, resource_name: Optional[str], template_name: str) -> List[str]:
+        schema = self.get_action_schema(resource_name, template_name) or {}
+        goal = (schema.get("properties") or {}).get("goal") or {}
+        props = goal.get("properties") or {}
+        required = goal.get("required") or []
+        return list(dict.fromkeys(required + list(props.keys())))

unilabos/workflow/convert_from_json.py

@@ -0,0 +1,356 @@
+"""
+JSON 工作流转换模块
+
+提供从多种 JSON 格式转换为统一工作流格式的功能。
+支持的格式：
+1. workflow/reagent 格式
+2. steps_info/labware_info 格式
+"""
+
+import json
+from os import PathLike
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set, Tuple, Union
+
+from unilabos.workflow.common import WorkflowGraph, build_protocol_graph
+from unilabos.registry.registry import lab_registry
+
+
+def get_action_handles(resource_name: str, template_name: str) -> Dict[str, List[str]]:
+    """
+    从 registry 获取指定设备和动作的 handles 配置
+
+    Args:
+        resource_name: 设备资源名称，如 "liquid_handler.prcxi"
+        template_name: 动作模板名称，如 "transfer_liquid"
+
+    Returns:
+        包含 source 和 target handler_keys 的字典:
+        {"source": ["sources_out", "targets_out", ...], "target": ["sources", "targets", ...]}
+    """
+    result = {"source": [], "target": []}
+
+    device_info = lab_registry.device_type_registry.get(resource_name, {})
+    if not device_info:
+        return result
+
+    action_mappings = device_info.get("class", {}).get("action_value_mappings", {})
+    action_config = action_mappings.get(template_name, {})
+    handles = action_config.get("handles", {})
+
+    if isinstance(handles, dict):
+        # 处理 input handles (作为 target)
+        for handle in handles.get("input", []):
+            handler_key = handle.get("handler_key", "")
+            if handler_key:
+                result["source"].append(handler_key)
+        # 处理 output handles (作为 source)
+        for handle in handles.get("output", []):
+            handler_key = handle.get("handler_key", "")
+            if handler_key:
+                result["target"].append(handler_key)
+
+    return result
+
+
+def validate_workflow_handles(graph: WorkflowGraph) -> Tuple[bool, List[str]]:
+    """
+    校验工作流图中所有边的句柄配置是否正确
+
+    Args:
+        graph: 工作流图对象
+
+    Returns:
+        (is_valid, errors): 是否有效，错误信息列表
+    """
+    errors = []
+    nodes = graph.nodes
+
+    for edge in graph.edges:
+        left_uuid = edge.get("source")
+        right_uuid = edge.get("target")
+        # target_handle_key是target, right的输入节点（入节点）
+        # source_handle_key是source, left的输出节点（出节点）
+        right_source_conn_key = edge.get("target_handle_key", "")
+        left_target_conn_key = edge.get("source_handle_key", "")
+
+        # 获取源节点和目标节点信息
+        left_node = nodes.get(left_uuid, {})
+        right_node = nodes.get(right_uuid, {})
+
+        left_res_name = left_node.get("resource_name", "")
+        left_template_name = left_node.get("template_name", "")
+        right_res_name = right_node.get("resource_name", "")
+        right_template_name = right_node.get("template_name", "")
+
+        # 获取源节点的 output handles
+        left_node_handles = get_action_handles(left_res_name, left_template_name)
+        target_valid_keys = left_node_handles.get("target", [])
+        target_valid_keys.append("ready")
+
+        # 获取目标节点的 input handles
+        right_node_handles = get_action_handles(right_res_name, right_template_name)
+        source_valid_keys = right_node_handles.get("source", [])
+        source_valid_keys.append("ready")
+
+        # 如果节点配置了 output handles，则 source_port 必须有效
+        if not right_source_conn_key:
+            node_name = left_node.get("name", left_uuid[:8])
+            errors.append(f"源节点 '{node_name}' 的 source_handle_key 为空，" f"应设置为: {source_valid_keys}")
+        elif right_source_conn_key not in source_valid_keys:
+            node_name = left_node.get("name", left_uuid[:8])
+            errors.append(
+                f"源节点 '{node_name}' 的 source 端点 '{right_source_conn_key}' 不存在，" f"支持的端点: {source_valid_keys}"
+            )
+
+        # 如果节点配置了 input handles，则 target_port 必须有效
+        if not left_target_conn_key:
+            node_name = right_node.get("name", right_uuid[:8])
+            errors.append(f"目标节点 '{node_name}' 的 target_handle_key 为空，" f"应设置为: {target_valid_keys}")
+        elif left_target_conn_key not in target_valid_keys:
+            node_name = right_node.get("name", right_uuid[:8])
+            errors.append(
+                f"目标节点 '{node_name}' 的 target 端点 '{left_target_conn_key}' 不存在，"
+                f"支持的端点: {target_valid_keys}"
+            )
+
+    return len(errors) == 0, errors
+
+
+# action 到 resource_name 的映射
+ACTION_RESOURCE_MAPPING: Dict[str, str] = {
+    # 生物实验操作
+    "transfer_liquid": "liquid_handler.prcxi",
+    "transfer": "liquid_handler.prcxi",
+    "incubation": "incubator.prcxi",
+    "move_labware": "labware_mover.prcxi",
+    "oscillation": "shaker.prcxi",
+    # 有机化学操作
+    "HeatChillToTemp": "heatchill.chemputer",
+    "StopHeatChill": "heatchill.chemputer",
+    "StartHeatChill": "heatchill.chemputer",
+    "HeatChill": "heatchill.chemputer",
+    "Dissolve": "stirrer.chemputer",
+    "Transfer": "liquid_handler.chemputer",
+    "Evaporate": "rotavap.chemputer",
+    "Recrystallize": "reactor.chemputer",
+    "Filter": "filter.chemputer",
+    "Dry": "dryer.chemputer",
+    "Add": "liquid_handler.chemputer",
+}
+
+
+def normalize_steps(data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    将不同格式的步骤数据规范化为统一格式
+
+    支持的输入格式：
+    - action + parameters
+    - action + action_args
+    - operation + parameters
+
+    Args:
+        data: 原始步骤数据列表
+
+    Returns:
+        规范化后的步骤列表，格式为 [{"action": str, "parameters": dict, "description": str?, "step_number": int?}, ...]
+    """
+    normalized = []
+    for idx, step in enumerate(data):
+        # 获取动作名称（支持 action 或 operation 字段）
+        action = step.get("action") or step.get("operation")
+        if not action:
+            continue
+
+        # 获取参数（支持 parameters 或 action_args 字段）
+        raw_params = step.get("parameters") or step.get("action_args") or {}
+        params = dict(raw_params)
+
+        # 规范化 source/target -> sources/targets
+        if "source" in raw_params and "sources" not in raw_params:
+            params["sources"] = raw_params["source"]
+        if "target" in raw_params and "targets" not in raw_params:
+            params["targets"] = raw_params["target"]
+
+        # 获取描述（支持 description 或 purpose 字段）
+        description = step.get("description") or step.get("purpose")
+
+        # 获取步骤编号（优先使用原始数据中的 step_number，否则使用索引+1）
+        step_number = step.get("step_number", idx + 1)
+
+        step_dict = {"action": action, "parameters": params, "step_number": step_number}
+        if description:
+            step_dict["description"] = description
+
+        normalized.append(step_dict)
+
+    return normalized
+
+
+def normalize_labware(data: List[Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
+    """
+    将不同格式的 labware 数据规范化为统一的字典格式
+
+    支持的输入格式：
+    - reagent_name + material_name + positions
+    - name + labware + slot
+
+    Args:
+        data: 原始 labware 数据列表
+
+    Returns:
+        规范化后的 labware 字典，格式为 {name: {"slot": int, "labware": str, "well": list, "type": str, "role": str, "name": str}, ...}
+    """
+    labware = {}
+    for item in data:
+        # 获取 key 名称（优先使用 reagent_name，其次是 material_name 或 name）
+        reagent_name = item.get("reagent_name")
+        key = reagent_name or item.get("material_name") or item.get("name")
+        if not key:
+            continue
+
+        key = str(key)
+
+        # 处理重复 key，自动添加后缀
+        idx = 1
+        original_key = key
+        while key in labware:
+            idx += 1
+            key = f"{original_key}_{idx}"
+
+        labware[key] = {
+            "slot": item.get("positions") or item.get("slot"),
+            "labware": item.get("material_name") or item.get("labware"),
+            "well": item.get("well", []),
+            "type": item.get("type", "reagent"),
+            "role": item.get("role", ""),
+            "name": key,
+        }
+
+    return labware
+
+
+def convert_from_json(
+    data: Union[str, PathLike, Dict[str, Any]],
+    workstation_name: str = "PRCXi",
+    validate: bool = True,
+) -> WorkflowGraph:
+    """
+    从 JSON 数据或文件转换为 WorkflowGraph
+
+    支持的 JSON 格式：
+    1. {"workflow": [...], "reagent": {...}} - 直接格式
+    2. {"steps_info": [...], "labware_info": [...]} - 需要规范化的格式
+
+    Args:
+        data: JSON 文件路径、字典数据、或 JSON 字符串
+        workstation_name: 工作站名称，默认 "PRCXi"
+        validate: 是否校验句柄配置，默认 True
+
+    Returns:
+        WorkflowGraph: 构建好的工作流图
+
+    Raises:
+        ValueError: 不支持的 JSON 格式 或 句柄校验失败
+        FileNotFoundError: 文件不存在
+        json.JSONDecodeError: JSON 解析失败
+    """
+    # 处理输入数据
+    if isinstance(data, (str, PathLike)):
+        path = Path(data)
+        if path.exists():
+            with path.open("r", encoding="utf-8") as fp:
+                json_data = json.load(fp)
+        elif isinstance(data, str):
+            # 尝试作为 JSON 字符串解析
+            json_data = json.loads(data)
+        else:
+            raise FileNotFoundError(f"文件不存在: {data}")
+    elif isinstance(data, dict):
+        json_data = data
+    else:
+        raise TypeError(f"不支持的数据类型: {type(data)}")
+
+    # 根据格式解析数据
+    if "workflow" in json_data and "reagent" in json_data:
+        # 格式1: workflow/reagent（已经是规范格式）
+        protocol_steps = json_data["workflow"]
+        labware_info = json_data["reagent"]
+    elif "steps_info" in json_data and "labware_info" in json_data:
+        # 格式2: steps_info/labware_info（需要规范化）
+        protocol_steps = normalize_steps(json_data["steps_info"])
+        labware_info = normalize_labware(json_data["labware_info"])
+    elif "steps" in json_data and "labware" in json_data:
+        # 格式3: steps/labware（另一种常见格式）
+        protocol_steps = normalize_steps(json_data["steps"])
+        if isinstance(json_data["labware"], list):
+            labware_info = normalize_labware(json_data["labware"])
+        else:
+            labware_info = json_data["labware"]
+    else:
+        raise ValueError(
+            "不支持的 JSON 格式。支持的格式：\n"
+            "1. {'workflow': [...], 'reagent': {...}}\n"
+            "2. {'steps_info': [...], 'labware_info': [...]}\n"
+            "3. {'steps': [...], 'labware': [...]}"
+        )
+
+    # 构建工作流图
+    graph = build_protocol_graph(
+        labware_info=labware_info,
+        protocol_steps=protocol_steps,
+        workstation_name=workstation_name,
+        action_resource_mapping=ACTION_RESOURCE_MAPPING,
+    )
+
+    # 校验句柄配置
+    if validate:
+        is_valid, errors = validate_workflow_handles(graph)
+        if not is_valid:
+            import warnings
+
+            for error in errors:
+                warnings.warn(f"句柄校验警告: {error}")
+
+    return graph
+
+
+def convert_json_to_node_link(
+    data: Union[str, PathLike, Dict[str, Any]],
+    workstation_name: str = "PRCXi",
+) -> Dict[str, Any]:
+    """
+    将 JSON 数据转换为 node-link 格式的字典
+
+    Args:
+        data: JSON 文件路径、字典数据、或 JSON 字符串
+        workstation_name: 工作站名称，默认 "PRCXi"
+
+    Returns:
+        Dict: node-link 格式的工作流数据
+    """
+    graph = convert_from_json(data, workstation_name)
+    return graph.to_node_link_dict()
+
+
+def convert_json_to_workflow_list(
+    data: Union[str, PathLike, Dict[str, Any]],
+    workstation_name: str = "PRCXi",
+) -> List[Dict[str, Any]]:
+    """
+    将 JSON 数据转换为工作流列表格式
+
+    Args:
+        data: JSON 文件路径、字典数据、或 JSON 字符串
+        workstation_name: 工作站名称，默认 "PRCXi"
+
+    Returns:
+        List: 工作流节点列表
+    """
+    graph = convert_from_json(data, workstation_name)
+    return graph.to_dict()
+
+
+# 为了向后兼容，保留下划线前缀的别名
+_normalize_steps = normalize_steps
+_normalize_labware = normalize_labware

unilabos/workflow/from_python_script.py

@@ -0,0 +1,241 @@
+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

@@ -0,0 +1,131 @@
+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.10.14</version>
+  <version>0.10.13</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>