gather query

(cherry picked from commit 176de521b4)

docs/user_guide/best_practice.md

@@ -439,9 +439,6 @@ unilab --ak your_ak --sk your_sk -g test/experiments/mock_devices/mock_all.json
 1. 访问 Web 界面，进入"仪器耗材"模块
 2. 在"仪器设备"区域找到并添加上述设备
 3. 在"物料耗材"区域找到并添加容器
-4. 在workstation中配置protocol_type包含PumpTransferProtocol
-
-![添加Protocol类型](image/add_protocol.png)
 
 ![物料列表](image/material.png)
 

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(

tests/workflow/test.json

@@ -1,213 +0,0 @@
-{
-  "workflow": [
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines",
-        "targets": "Liquid_1",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines",
-        "targets": "Liquid_2",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines",
-        "targets": "Liquid_3",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines_2",
-        "targets": "Liquid_4",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines_2",
-        "targets": "Liquid_5",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines_2",
-        "targets": "Liquid_6",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines_3",
-        "targets": "dest_set",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines_3",
-        "targets": "dest_set_2",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines_3",
-        "targets": "dest_set_3",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    }
-  ],
-  "reagent": {
-    "Liquid_1": {
-      "slot": 1,
-      "well": [
-        "A4",
-        "A7",
-        "A10"
-      ],
-      "labware": "rep 1"
-    },
-    "Liquid_4": {
-      "slot": 1,
-      "well": [
-        "A4",
-        "A7",
-        "A10"
-      ],
-      "labware": "rep 1"
-    },
-    "dest_set": {
-      "slot": 1,
-      "well": [
-        "A4",
-        "A7",
-        "A10"
-      ],
-      "labware": "rep 1"
-    },
-    "Liquid_2": {
-      "slot": 2,
-      "well": [
-        "A3",
-        "A5",
-        "A8"
-      ],
-      "labware": "rep 2"
-    },
-    "Liquid_5": {
-      "slot": 2,
-      "well": [
-        "A3",
-        "A5",
-        "A8"
-      ],
-      "labware": "rep 2"
-    },
-    "dest_set_2": {
-      "slot": 2,
-      "well": [
-        "A3",
-        "A5",
-        "A8"
-      ],
-      "labware": "rep 2"
-    },
-    "Liquid_3": {
-      "slot": 3,
-      "well": [
-        "A4",
-        "A6",
-        "A10"
-      ],
-      "labware": "rep 3"
-    },
-    "Liquid_6": {
-      "slot": 3,
-      "well": [
-        "A4",
-        "A6",
-        "A10"
-      ],
-      "labware": "rep 3"
-    },
-    "dest_set_3": {
-      "slot": 3,
-      "well": [
-        "A4",
-        "A6",
-        "A10"
-      ],
-      "labware": "rep 3"
-    },
-    "cell_lines": {
-      "slot": 4,
-      "well": [
-        "A1",
-        "A3",
-        "A5"
-      ],
-      "labware": "DRUG + YOYO-MEDIA"
-    },
-    "cell_lines_2": {
-      "slot": 4,
-      "well": [
-        "A1",
-        "A3",
-        "A5"
-      ],
-      "labware": "DRUG + YOYO-MEDIA"
-    },
-    "cell_lines_3": {
-      "slot": 4,
-      "well": [
-        "A1",
-        "A3",
-        "A5"
-      ],
-      "labware": "DRUG + YOYO-MEDIA"
-    }
-  }
-}

unilabos/app/web/client.py

@@ -359,7 +359,9 @@ class HTTPClient:
         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,

unilabos/app/ws_client.py

@@ -439,7 +439,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())
@@ -517,7 +517,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:
@@ -1026,7 +1026,7 @@ class QueueProcessor:
 
     def _run(self):
         """运行队列处理主循环"""
-        logger.debug("[QueueProcessor] Queue processor started")
+        logger.trace("[QueueProcessor] Queue processor started")
 
         while self.is_running:
             try:
@@ -1236,7 +1236,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:
@@ -1249,13 +1248,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客户端"""

unilabos/devices/liquid_handling/prcxi/prcxi.py

@@ -30,30 +30,9 @@ from pylabrobot.liquid_handling.standard import (
     ResourceMove,
     ResourceDrop,
 )
-from pylabrobot.resources import (
+from pylabrobot.resources import ResourceHolder, ResourceStack, Tip, Deck, Plate, Well, TipRack, Resource, Container, Coordinate, TipSpot, Trash, PlateAdapter, TubeRack
-    ResourceHolder,
-    ResourceStack,
-    Tip,
-    Deck,
-    Plate,
-    Well,
-    TipRack,
-    Resource,
-    Container,
-    Coordinate,
-    TipSpot,
-    Trash,
-    PlateAdapter,
-    TubeRack,
-)
 
-from unilabos.devices.liquid_handling.liquid_handler_abstract import (
+from unilabos.devices.liquid_handling.liquid_handler_abstract import LiquidHandlerAbstract, SimpleReturn
-    LiquidHandlerAbstract,
-    SimpleReturn,
-    SetLiquidReturn,
-    SetLiquidFromPlateReturn,
-)
-from unilabos.registry.placeholder_type import ResourceSlot
 from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
 
 
@@ -101,7 +80,6 @@ class PRCXI9300Deck(Deck):
         self.slots[slot - 1] = resource
         super().assign_child_resource(resource, location=self.slot_locations[slot - 1])
 
-
 class PRCXI9300Container(Plate):
     """PRCXI 9300 的专用 Container 类，继承自 Plate，用于槽位定位和未知模块。
 
@@ -130,29 +108,20 @@ class PRCXI9300Container(Plate):
     def serialize_state(self) -> Dict[str, Dict[str, Any]]:
         data = super().serialize_state()
         data.update(self._unilabos_state)
-        return data
+        return data   
-
-
 class PRCXI9300Plate(Plate):
-    """
+    """ 
     专用孔板类：
     1. 继承自 PLR 原生 Plate，保留所有物理特性。
     2. 增加 material_info 参数，用于在初始化时直接绑定 Unilab UUID。
     """
-
+    def __init__(self, name: str, size_x: float, size_y: float, size_z: float, 
-    def __init__(
+                 category: str = "plate", 
-        self,
+                 ordered_items: collections.OrderedDict = None, 
-        name: str,
+                 ordering: Optional[collections.OrderedDict] = None,
-        size_x: float,
+                 model: Optional[str] = None, 
-        size_y: float,
+                 material_info: Optional[Dict[str, Any]] = None, 
-        size_z: float,
+                 **kwargs):
-        category: str = "plate",
-        ordered_items: collections.OrderedDict = None,
-        ordering: Optional[collections.OrderedDict] = None,
-        model: Optional[str] = None,
-        material_info: Optional[Dict[str, Any]] = None,
-        **kwargs,
-    ):
         # 如果 ordered_items 不为 None，直接使用
         if ordered_items is not None:
             items = ordered_items
@@ -173,34 +142,40 @@ class PRCXI9300Plate(Plate):
         else:
             items = None
             ordering_param = None
-
+        
         # 根据情况传递不同的参数
         if items is not None:
-            super().__init__(
+            super().__init__(name, size_x, size_y, size_z, 
-                name, size_x, size_y, size_z, ordered_items=items, category=category, model=model, **kwargs
+                             ordered_items=items,
-            )
+                             category=category,
+                             model=model, **kwargs)
         elif ordering_param is not None:
             # 传递 ordering 参数，让 Plate 自己创建 Well 对象
-            super().__init__(
+            super().__init__(name, size_x, size_y, size_z, 
-                name, size_x, size_y, size_z, ordering=ordering_param, category=category, model=model, **kwargs
+                             ordering=ordering_param,
-            )
+                             category=category,
+                             model=model, **kwargs)
         else:
-            super().__init__(name, size_x, size_y, size_z, category=category, model=model, **kwargs)
+            super().__init__(name, size_x, size_y, size_z, 
-
+                             category=category,
+                             model=model, **kwargs)
+        
         self._unilabos_state = {}
         if material_info:
             self._unilabos_state["Material"] = material_info
+        
 
     def load_state(self, state: Dict[str, Any]) -> None:
         super().load_state(state)
         self._unilabos_state = state
 
+
     def serialize_state(self) -> Dict[str, Dict[str, Any]]:
         try:
             data = super().serialize_state()
         except AttributeError:
             data = {}
-        if hasattr(self, "_unilabos_state") and self._unilabos_state:
+        if hasattr(self, '_unilabos_state') and self._unilabos_state:
             safe_state = {}
             for k, v in self._unilabos_state.items():
                 # 如果是 Material 字典，深入检查
@@ -213,32 +188,23 @@ class PRCXI9300Plate(Plate):
                         else:
                             # 打印日志提醒（可选）
                             # print(f"Warning: Removing non-serializable key {mk} from {self.name}")
-                            pass
+                            pass 
                     safe_state[k] = safe_material
                 # 其他顶层属性也进行类型检查
                 elif isinstance(v, (str, int, float, bool, list, dict, type(None))):
                     safe_state[k] = v
-
+            
             data.update(safe_state)
-        return data  # 其他顶层属性也进行类型检查
+        return data            # 其他顶层属性也进行类型检查
-
-
 class PRCXI9300TipRack(TipRack):
-    """专用吸头盒类"""
+    """ 专用吸头盒类 """
-
+    def __init__(self, name: str, size_x: float, size_y: float, size_z: float, 
-    def __init__(
+                 category: str = "tip_rack", 
-        self,
+                 ordered_items: collections.OrderedDict = None, 
-        name: str,
+                 ordering: Optional[collections.OrderedDict] = None,
-        size_x: float,
+                 model: Optional[str] = None,
-        size_y: float,
+                 material_info: Optional[Dict[str, Any]] = None,
-        size_z: float,
+                 **kwargs):
-        category: str = "tip_rack",
-        ordered_items: collections.OrderedDict = None,
-        ordering: Optional[collections.OrderedDict] = None,
-        model: Optional[str] = None,
-        material_info: Optional[Dict[str, Any]] = None,
-        **kwargs,
-    ):
         # 如果 ordered_items 不为 None，直接使用
         if ordered_items is not None:
             items = ordered_items
@@ -259,23 +225,27 @@ class PRCXI9300TipRack(TipRack):
         else:
             items = None
             ordering_param = None
-
+        
         # 根据情况传递不同的参数
         if items is not None:
-            super().__init__(
+            super().__init__(name, size_x, size_y, size_z, 
-                name, size_x, size_y, size_z, ordered_items=items, category=category, model=model, **kwargs
+                             ordered_items=items,
-            )
+                             category=category, 
+                             model=model, **kwargs)
         elif ordering_param is not None:
             # 传递 ordering 参数，让 TipRack 自己创建 Tip 对象
-            super().__init__(
+            super().__init__(name, size_x, size_y, size_z, 
-                name, size_x, size_y, size_z, ordering=ordering_param, category=category, model=model, **kwargs
+                             ordering=ordering_param,
-            )
+                             category=category, 
+                             model=model, **kwargs)
         else:
-            super().__init__(name, size_x, size_y, size_z, category=category, model=model, **kwargs)
+            super().__init__(name, size_x, size_y, size_z, 
+                             category=category, 
+                             model=model, **kwargs)
         self._unilabos_state = {}
         if material_info:
             self._unilabos_state["Material"] = material_info
-
+            
     def load_state(self, state: Dict[str, Any]) -> None:
         super().load_state(state)
         self._unilabos_state = state
@@ -285,7 +255,7 @@ class PRCXI9300TipRack(TipRack):
             data = super().serialize_state()
         except AttributeError:
             data = {}
-        if hasattr(self, "_unilabos_state") and self._unilabos_state:
+        if hasattr(self, '_unilabos_state') and self._unilabos_state:
             safe_state = {}
             for k, v in self._unilabos_state.items():
                 # 如果是 Material 字典，深入检查
@@ -298,33 +268,26 @@ class PRCXI9300TipRack(TipRack):
                         else:
                             # 打印日志提醒（可选）
                             # print(f"Warning: Removing non-serializable key {mk} from {self.name}")
-                            pass
+                            pass 
                     safe_state[k] = safe_material
                 # 其他顶层属性也进行类型检查
                 elif isinstance(v, (str, int, float, bool, list, dict, type(None))):
                     safe_state[k] = v
-
+            
             data.update(safe_state)
         return data
-
+    
-
 class PRCXI9300Trash(Trash):
     """PRCXI 9300 的专用 Trash 类，继承自 Trash。
 
     该类定义了 PRCXI 9300 的工作台布局和槽位信息。
     """
 
-    def __init__(
+    def __init__(self, name: str, size_x: float, size_y: float, size_z: float, 
-        self,
+                 category: str = "trash", 
-        name: str,
+                 material_info: Optional[Dict[str, Any]] = None,
-        size_x: float,
+                 **kwargs):
-        size_y: float,
+        
-        size_z: float,
-        category: str = "trash",
-        material_info: Optional[Dict[str, Any]] = None,
-        **kwargs,
-    ):
-
         if name != "trash":
             print(f"Warning: PRCXI9300Trash usually expects name='trash' for backend logic, but got '{name}'.")
         super().__init__(name, size_x, size_y, size_z, **kwargs)
@@ -343,7 +306,7 @@ class PRCXI9300Trash(Trash):
             data = super().serialize_state()
         except AttributeError:
             data = {}
-        if hasattr(self, "_unilabos_state") and self._unilabos_state:
+        if hasattr(self, '_unilabos_state') and self._unilabos_state:
             safe_state = {}
             for k, v in self._unilabos_state.items():
                 # 如果是 Material 字典，深入检查
@@ -356,37 +319,29 @@ class PRCXI9300Trash(Trash):
                         else:
                             # 打印日志提醒（可选）
                             # print(f"Warning: Removing non-serializable key {mk} from {self.name}")
-                            pass
+                            pass 
                     safe_state[k] = safe_material
                 # 其他顶层属性也进行类型检查
                 elif isinstance(v, (str, int, float, bool, list, dict, type(None))):
                     safe_state[k] = v
-
+            
             data.update(safe_state)
         return data
 
-
 class PRCXI9300TubeRack(TubeRack):
     """
     专用管架类：用于 EP 管架、试管架等。
     继承自 PLR 的 TubeRack，并支持注入 material_info (UUID)。
     """
-
+    def __init__(self, name: str, size_x: float, size_y: float, size_z: float, 
-    def __init__(
+                 category: str = "tube_rack", 
-        self,
+                 items: Optional[Dict[str, Any]] = None,
-        name: str,
+                 ordered_items: Optional[OrderedDict] = None,
-        size_x: float,
+                 ordering: Optional[OrderedDict] = None,
-        size_y: float,
+                 model: Optional[str] = None,
-        size_z: float,
+                 material_info: Optional[Dict[str, Any]] = None, 
-        category: str = "tube_rack",
+                 **kwargs):
-        items: Optional[Dict[str, Any]] = None,
+        
-        ordered_items: Optional[OrderedDict] = None,
-        ordering: Optional[OrderedDict] = None,
-        model: Optional[str] = None,
-        material_info: Optional[Dict[str, Any]] = None,
-        **kwargs,
-    ):
-
         # 如果 ordered_items 不为 None，直接使用
         if ordered_items is not None:
             items_to_pass = ordered_items
@@ -412,16 +367,24 @@ class PRCXI9300TubeRack(TubeRack):
         else:
             items_to_pass = None
             ordering_param = None
-
+        
         # 根据情况传递不同的参数
         if items_to_pass is not None:
-            super().__init__(name, size_x, size_y, size_z, ordered_items=items_to_pass, model=model, **kwargs)
+            super().__init__(name, size_x, size_y, size_z, 
+                             ordered_items=items_to_pass, 
+                             model=model, 
+                             **kwargs)
         elif ordering_param is not None:
             # 传递 ordering 参数，让 TubeRack 自己创建 Tube 对象
-            super().__init__(name, size_x, size_y, size_z, ordering=ordering_param, model=model, **kwargs)
+            super().__init__(name, size_x, size_y, size_z, 
+                             ordering=ordering_param,
+                             model=model, 
+                             **kwargs)
         else:
-            super().__init__(name, size_x, size_y, size_z, model=model, **kwargs)
+            super().__init__(name, size_x, size_y, size_z, 
-
+                             model=model, 
+                             **kwargs)
+        
         self._unilabos_state = {}
         if material_info:
             self._unilabos_state["Material"] = material_info
@@ -431,7 +394,7 @@ class PRCXI9300TubeRack(TubeRack):
             data = super().serialize_state()
         except AttributeError:
             data = {}
-        if hasattr(self, "_unilabos_state") and self._unilabos_state:
+        if hasattr(self, '_unilabos_state') and self._unilabos_state:
             safe_state = {}
             for k, v in self._unilabos_state.items():
                 # 如果是 Material 字典，深入检查
@@ -444,41 +407,33 @@ class PRCXI9300TubeRack(TubeRack):
                         else:
                             # 打印日志提醒（可选）
                             # print(f"Warning: Removing non-serializable key {mk} from {self.name}")
-                            pass
+                            pass 
                     safe_state[k] = safe_material
                 # 其他顶层属性也进行类型检查
                 elif isinstance(v, (str, int, float, bool, list, dict, type(None))):
                     safe_state[k] = v
-
+            
             data.update(safe_state)
         return data
 
-
 class PRCXI9300PlateAdapter(PlateAdapter):
     """
     专用板式适配器类：用于承载 Plate 的底座（如 PCR 适配器、磁吸架等）。
     支持注入 material_info (UUID)。
     """
-
+    def __init__(self, name: str, size_x: float, size_y: float, size_z: float, 
-    def __init__(
+                 category: str = "plate_adapter", 
-        self,
+                 model: Optional[str] = None,
-        name: str,
+                 material_info: Optional[Dict[str, Any]] = None, 
-        size_x: float,
+                 # 参数给予默认值 (标准96孔板尺寸)
-        size_y: float,
+                 adapter_hole_size_x: float = 127.76, 
-        size_z: float,
+                 adapter_hole_size_y: float = 85.48, 
-        category: str = "plate_adapter",
+                 adapter_hole_size_z: float = 10.0, # 假设凹槽深度或板子放置高度
-        model: Optional[str] = None,
+                 dx: Optional[float] = None,
-        material_info: Optional[Dict[str, Any]] = None,
+                 dy: Optional[float] = None,
-        # 参数给予默认值 (标准96孔板尺寸)
+                 dz: float = 0.0, # 默认Z轴偏移
-        adapter_hole_size_x: float = 127.76,
+                 **kwargs):
-        adapter_hole_size_y: float = 85.48,
+        
-        adapter_hole_size_z: float = 10.0,  # 假设凹槽深度或板子放置高度
-        dx: Optional[float] = None,
-        dy: Optional[float] = None,
-        dz: float = 0.0,  # 默认Z轴偏移
-        **kwargs,
-    ):
-
         # 自动居中计算：如果未指定 dx/dy，则根据适配器尺寸和孔尺寸计算居中位置
         if dx is None:
             dx = (size_x - adapter_hole_size_x) / 2
@@ -486,20 +441,20 @@ class PRCXI9300PlateAdapter(PlateAdapter):
             dy = (size_y - adapter_hole_size_y) / 2
 
         super().__init__(
-            name=name,
+            name=name, 
-            size_x=size_x,
+            size_x=size_x, 
-            size_y=size_y,
+            size_y=size_y, 
-            size_z=size_z,
+            size_z=size_z, 
             dx=dx,
             dy=dy,
             dz=dz,
             adapter_hole_size_x=adapter_hole_size_x,
             adapter_hole_size_y=adapter_hole_size_y,
             adapter_hole_size_z=adapter_hole_size_z,
-            model=model,
+            model=model, 
-            **kwargs,
+            **kwargs
         )
-
+        
         self._unilabos_state = {}
         if material_info:
             self._unilabos_state["Material"] = material_info
@@ -509,7 +464,7 @@ class PRCXI9300PlateAdapter(PlateAdapter):
             data = super().serialize_state()
         except AttributeError:
             data = {}
-        if hasattr(self, "_unilabos_state") and self._unilabos_state:
+        if hasattr(self, '_unilabos_state') and self._unilabos_state:
             safe_state = {}
             for k, v in self._unilabos_state.items():
                 # 如果是 Material 字典，深入检查
@@ -522,16 +477,15 @@ class PRCXI9300PlateAdapter(PlateAdapter):
                         else:
                             # 打印日志提醒（可选）
                             # print(f"Warning: Removing non-serializable key {mk} from {self.name}")
-                            pass
+                            pass 
                     safe_state[k] = safe_material
                 # 其他顶层属性也进行类型检查
                 elif isinstance(v, (str, int, float, bool, list, dict, type(None))):
                     safe_state[k] = v
-
+            
             data.update(safe_state)
         return data
 
-
 class PRCXI9300Handler(LiquidHandlerAbstract):
     support_touch_tip = False
 
@@ -564,9 +518,7 @@ class PRCXI9300Handler(LiquidHandlerAbstract):
                 if "Material" in child.children[0]._unilabos_state:
                     number = int(child.name.replace("T", ""))
                     tablets_info.append(
-                        WorkTablets(
+                        WorkTablets(Number=number, Code=f"T{number}", Material=child.children[0]._unilabos_state["Material"])
-                            Number=number, Code=f"T{number}", Material=child.children[0]._unilabos_state["Material"]
-                        )
                     )
         if is_9320:
             print("当前设备是9320")
@@ -586,14 +538,9 @@ class PRCXI9300Handler(LiquidHandlerAbstract):
         super().post_init(ros_node)
         self._unilabos_backend.post_init(ros_node)
 
-    def set_liquid(self, wells: list[Well], liquid_names: list[str], volumes: list[float]) -> SetLiquidReturn:
+    def set_liquid(self, wells: list[Well], liquid_names: list[str], volumes: list[float]) -> SimpleReturn:
         return super().set_liquid(wells, liquid_names, volumes)
 
-    def set_liquid_from_plate(
-        self, plate: ResourceSlot, well_names: list[str], liquid_names: list[str], volumes: list[float]
-    ) -> SetLiquidFromPlateReturn:
-        return super().set_liquid_from_plate(plate, well_names, liquid_names, volumes)
-
     def set_group(self, group_name: str, wells: List[Well], volumes: List[float]):
         return super().set_group(group_name, wells, volumes)
 
@@ -852,8 +799,7 @@ class PRCXI9300Handler(LiquidHandlerAbstract):
         return await self._unilabos_backend.shaker_action(time, module_no, amplitude, is_wait)
 
     async def heater_action(self, temperature: float, time: int):
-        return await self._unilabos_backend.heater_action(temperature, time)
+        return await self._unilabos_backend.heater_action(temperature, time)  
-
     async def move_plate(
         self,
         plate: Plate,
@@ -876,11 +822,10 @@ class PRCXI9300Handler(LiquidHandlerAbstract):
             drop_direction,
             pickup_direction,
             pickup_distance_from_top,
-            target_plate_number=to,
+            target_plate_number = to,
             **backend_kwargs,
         )
 
-
 class PRCXI9300Backend(LiquidHandlerBackend):
     """PRCXI 9300 的后端实现，继承自 LiquidHandlerBackend。
 
@@ -933,28 +878,31 @@ class PRCXI9300Backend(LiquidHandlerBackend):
         self.steps_todo_list.append(step)
         return step
 
-    async def pick_up_resource(self, pickup: ResourcePickup, **backend_kwargs):
 
-        resource = pickup.resource
+    async def pick_up_resource(self, pickup: ResourcePickup, **backend_kwargs):
-        offset = pickup.offset
+        
-        pickup_distance_from_top = pickup.pickup_distance_from_top
+        resource=pickup.resource
-        direction = pickup.direction
+        offset=pickup.offset
+        pickup_distance_from_top=pickup.pickup_distance_from_top
+        direction=pickup.direction
 
         plate_number = int(resource.parent.name.replace("T", ""))
         is_whole_plate = True
         balance_height = 0
         step = self.api_client.clamp_jaw_pick_up(plate_number, is_whole_plate, balance_height)
-
+        
         self.steps_todo_list.append(step)
         return step
 
     async def drop_resource(self, drop: ResourceDrop, **backend_kwargs):
 
+
         plate_number = None
         target_plate_number = backend_kwargs.get("target_plate_number", None)
         if target_plate_number is not None:
             plate_number = int(target_plate_number.name.replace("T", ""))
 
+
         is_whole_plate = True
         balance_height = 0
         if plate_number is None:
@@ -963,6 +911,7 @@ class PRCXI9300Backend(LiquidHandlerBackend):
         self.steps_todo_list.append(step)
         return step
 
+
     async def heater_action(self, temperature: float, time: int):
         print(f"\n\nHeater action: temperature={temperature}, time={time}\n\n")
         # return await self.api_client.heater_action(temperature, time)
@@ -1019,7 +968,7 @@ class PRCXI9300Backend(LiquidHandlerBackend):
                 error_code = self.api_client.get_error_code()
                 if error_code:
                     print(f"PRCXI9300 error code detected: {error_code}")
-
+                
                 # 清除错误代码
                 self.api_client.clear_error_code()
                 print("PRCXI9300 error code cleared.")
@@ -1027,11 +976,11 @@ class PRCXI9300Backend(LiquidHandlerBackend):
                 # 执行重置
                 print("Starting PRCXI9300 reset...")
                 self.api_client.call("IAutomation", "Reset")
-
+                
                 # 检查重置状态并等待完成
                 while not self.is_reset_ok:
                     print("Waiting for PRCXI9300 to reset...")
-                    if hasattr(self, "_ros_node") and self._ros_node is not None:
+                    if hasattr(self, '_ros_node') and self._ros_node is not None:
                         await self._ros_node.sleep(1)
                     else:
                         await asyncio.sleep(1)
@@ -1049,7 +998,7 @@ class PRCXI9300Backend(LiquidHandlerBackend):
         """Pick up tips from the specified resource."""
         # INSERT_YOUR_CODE
         # Ensure use_channels is converted to a list of ints if it's an array
-        if hasattr(use_channels, "tolist"):
+        if hasattr(use_channels, 'tolist'):
             _use_channels = use_channels.tolist()
         else:
             _use_channels = list(use_channels) if use_channels is not None else None
@@ -1103,7 +1052,7 @@ class PRCXI9300Backend(LiquidHandlerBackend):
 
     async def drop_tips(self, ops: List[Drop], use_channels: List[int] = None):
         """Pick up tips from the specified resource."""
-        if hasattr(use_channels, "tolist"):
+        if hasattr(use_channels, 'tolist'):
             _use_channels = use_channels.tolist()
         else:
             _use_channels = list(use_channels) if use_channels is not None else None
@@ -1186,7 +1135,7 @@ class PRCXI9300Backend(LiquidHandlerBackend):
         none_keys: List[str] = [],
     ):
         """Mix liquid in the specified resources."""
-
+        
         plate_indexes = []
         for op in targets:
             deck = op.parent.parent.parent
@@ -1229,7 +1178,7 @@ class PRCXI9300Backend(LiquidHandlerBackend):
 
     async def aspirate(self, ops: List[SingleChannelAspiration], use_channels: List[int] = None):
         """Aspirate liquid from the specified resources."""
-        if hasattr(use_channels, "tolist"):
+        if hasattr(use_channels, 'tolist'):
             _use_channels = use_channels.tolist()
         else:
             _use_channels = list(use_channels) if use_channels is not None else None
@@ -1286,7 +1235,7 @@ class PRCXI9300Backend(LiquidHandlerBackend):
 
     async def dispense(self, ops: List[SingleChannelDispense], use_channels: List[int] = None):
         """Dispense liquid into the specified resources."""
-        if hasattr(use_channels, "tolist"):
+        if hasattr(use_channels, 'tolist'):
             _use_channels = use_channels.tolist()
         else:
             _use_channels = list(use_channels) if use_channels is not None else None
@@ -1467,6 +1416,7 @@ class PRCXI9300Api:
                 time.sleep(1)
         return success
 
+
     def call(self, service: str, method: str, params: Optional[list] = None) -> Any:
         payload = json.dumps(
             {"ServiceName": service, "MethodName": method, "Paramters": params or []}, separators=(",", ":")
@@ -1593,7 +1543,7 @@ class PRCXI9300Api:
         assist_fun5: str = "",
         liquid_method: str = "NormalDispense",
         axis: str = "Left",
-    ) -> Dict[str, Any]:
+        ) -> Dict[str, Any]:
         return {
             "StepAxis": axis,
             "Function": "Imbibing",
@@ -1671,7 +1621,7 @@ class PRCXI9300Api:
         assist_fun5: str = "",
         liquid_method: str = "NormalDispense",
         axis: str = "Left",
-    ) -> Dict[str, Any]:
+        ) -> Dict[str, Any]:
         return {
             "StepAxis": axis,
             "Function": "Blending",
@@ -1731,11 +1681,11 @@ class PRCXI9300Api:
             "LiquidDispensingMethod": liquid_method,
         }
 
-    def clamp_jaw_pick_up(
+    def clamp_jaw_pick_up(self,
-        self,
         plate_no: int,
         is_whole_plate: bool,
         balance_height: int,
+
     ) -> Dict[str, Any]:
         return {
             "StepAxis": "ClampingJaw",
@@ -1745,7 +1695,7 @@ class PRCXI9300Api:
             "HoleRow": 1,
             "HoleCol": 1,
             "BalanceHeight": balance_height,
-            "PlateOrHoleNum": f"T{plate_no}",
+            "PlateOrHoleNum": f"T{plate_no}"
         }
 
     def clamp_jaw_drop(
@@ -1753,6 +1703,7 @@ class PRCXI9300Api:
         plate_no: int,
         is_whole_plate: bool,
         balance_height: int,
+
     ) -> Dict[str, Any]:
         return {
             "StepAxis": "ClampingJaw",
@@ -1762,7 +1713,7 @@ class PRCXI9300Api:
             "HoleRow": 1,
             "HoleCol": 1,
             "BalanceHeight": balance_height,
-            "PlateOrHoleNum": f"T{plate_no}",
+            "PlateOrHoleNum": f"T{plate_no}"
         }
 
     def shaker_action(self, time: int, module_no: int, amplitude: int, is_wait: bool):
@@ -1775,7 +1726,6 @@ class PRCXI9300Api:
             "AssistFun4": is_wait,
         }
 
-
 class DefaultLayout:
 
     def __init__(self, product_name: str = "PRCXI9300"):
@@ -2154,9 +2104,7 @@ if __name__ == "__main__":
             size_y=50,
             size_z=10,
             category="tip_rack",
-            ordered_items=collections.OrderedDict(
+            ordered_items=collections.OrderedDict({k: f"{child_prefix}_{k}" for k, v in tip_racks["ordering"].items()}),
-                {k: f"{child_prefix}_{k}" for k, v in tip_racks["ordering"].items()}
-            ),
         )
         tip_rack_serialized = tip_rack.serialize()
         tip_rack_serialized["parent_name"] = deck.name
@@ -2351,37 +2299,43 @@ if __name__ == "__main__":
 
     A = tree_to_list([resource_plr_to_ulab(deck)])
     with open("deck.json", "w", encoding="utf-8") as f:
-        A.insert(
+        A.insert(0, {
-            0,
+            "id": "PRCXI",
-            {
+            "name": "PRCXI",
-                "id": "PRCXI",
+            "parent": None,
-                "name": "PRCXI",
+            "type": "device",
-                "parent": None,
+            "class": "liquid_handler.prcxi",
-                "type": "device",
+            "position": {
-                "class": "liquid_handler.prcxi",
+                "x": 0,
-                "position": {"x": 0, "y": 0, "z": 0},
+                "y": 0,
-                "config": {
+                "z": 0
-                    "deck": {
-                        "_resource_child_name": "PRCXI_Deck",
-                        "_resource_type": "unilabos.devices.liquid_handling.prcxi.prcxi:PRCXI9300Deck",
-                    },
-                    "host": "192.168.0.121",
-                    "port": 9999,
-                    "timeout": 10.0,
-                    "axis": "Right",
-                    "channel_num": 1,
-                    "setup": False,
-                    "debug": True,
-                    "simulator": True,
-                    "matrix_id": "5de524d0-3f95-406c-86dd-f83626ebc7cb",
-                    "is_9320": True,
-                },
-                "data": {},
-                "children": ["PRCXI_Deck"],
             },
-        )
+            "config": {
+                "deck": {
+                    "_resource_child_name": "PRCXI_Deck",
+                    "_resource_type": "unilabos.devices.liquid_handling.prcxi.prcxi:PRCXI9300Deck"
+                },
+                "host": "192.168.0.121",
+                "port": 9999,
+                "timeout": 10.0,
+                "axis": "Right",
+                "channel_num": 1,
+                "setup": False,
+                "debug": True,
+                "simulator": True,
+                "matrix_id": "5de524d0-3f95-406c-86dd-f83626ebc7cb",
+                "is_9320": True
+            },
+            "data": {},
+            "children": [
+                "PRCXI_Deck"
+            ]
+        })
         A[1]["parent"] = "PRCXI"
-        json.dump({"nodes": A, "links": []}, f, indent=4, ensure_ascii=False)
+        json.dump({
+            "nodes": A,
+            "links": []
+        }, f, indent=4, ensure_ascii=False)
 
     handler = PRCXI9300Handler(
         deck=deck,
@@ -2423,6 +2377,7 @@ if __name__ == "__main__":
     time.sleep(5)
     os._exit(0)
 
+
     prcxi_api = PRCXI9300Api(host="192.168.0.121", port=9999)
     prcxi_api.list_matrices()
     prcxi_api.get_all_materials()

unilabos/registry/devices/liquid_handler.yaml

@@ -9284,13 +9284,7 @@ liquid_handler.prcxi:
             data_source: handle
             data_type: resource
             handler_key: input_wells
-            label: 待设定液体孔
+            label: InputWells
-          output:
-          - data_key: wells.@flatten
-            data_source: executor
-            data_type: resource
-            handler_key: output_wells
-            label: 已设定液体孔
         placeholder_keys:
           wells: unilabos_resources
         result: {}
@@ -9406,163 +9400,6 @@ liquid_handler.prcxi:
           title: LiquidHandlerSetLiquid
           type: object
         type: LiquidHandlerSetLiquid
-      set_liquid_from_plate:
-        feedback: {}
-        goal: {}
-        goal_default:
-          liquid_names: null
-          plate: null
-          volumes: null
-          well_names: null
-        handles:
-          input:
-          - data_key: plate
-            data_source: handle
-            data_type: resource
-            handler_key: input_plate
-            label: 待设定液体板
-          output:
-          - data_key: plate.@flatten
-            data_source: executor
-            data_type: resource
-            handler_key: output_plate
-            label: 已设定液体板
-          - data_key: wells.@flatten
-            data_source: executor
-            data_type: resource
-            handler_key: output_wells
-            label: 已设定液体孔
-          - data_key: volumes
-            data_source: executor
-            data_type: number_array
-            handler_key: output_volumes
-            label: 各孔设定体积
-        placeholder_keys:
-          plate: unilabos_resources
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                liquid_names:
-                  items:
-                    type: string
-                  type: array
-                plate:
-                  properties:
-                    category:
-                      type: string
-                    children:
-                      items:
-                        type: string
-                      type: array
-                    config:
-                      type: string
-                    data:
-                      type: string
-                    id:
-                      type: string
-                    name:
-                      type: string
-                    parent:
-                      type: string
-                    pose:
-                      properties:
-                        orientation:
-                          properties:
-                            w:
-                              type: number
-                            x:
-                              type: number
-                            y:
-                              type: number
-                            z:
-                              type: number
-                          required:
-                          - x
-                          - y
-                          - z
-                          - w
-                          title: orientation
-                          type: object
-                        position:
-                          properties:
-                            x:
-                              type: number
-                            y:
-                              type: number
-                            z:
-                              type: number
-                          required:
-                          - x
-                          - y
-                          - z
-                          title: position
-                          type: object
-                      required:
-                      - position
-                      - orientation
-                      title: pose
-                      type: object
-                    sample_id:
-                      type: string
-                    type:
-                      type: string
-                  required:
-                  - id
-                  - name
-                  - sample_id
-                  - children
-                  - parent
-                  - type
-                  - category
-                  - pose
-                  - config
-                  - data
-                  title: plate
-                  type: object
-                volumes:
-                  items:
-                    type: number
-                  type: array
-                well_names:
-                  items:
-                    type: string
-                  type: array
-              required:
-              - plate
-              - well_names
-              - liquid_names
-              - volumes
-              type: object
-            result:
-              properties:
-                plate:
-                  items: {}
-                  title: Plate
-                  type: array
-                volumes:
-                  items:
-                    type: number
-                  title: Volumes
-                  type: array
-                wells:
-                  items: {}
-                  title: Wells
-                  type: array
-              required:
-              - plate
-              - wells
-              - volumes
-              title: SetLiquidFromPlateReturn
-              type: object
-          required:
-          - goal
-          title: set_liquid_from_plate参数
-          type: object
-        type: UniLabJsonCommand
       set_tiprack:
         feedback: {}
         goal:

unilabos/registry/registry.py

@@ -163,7 +163,6 @@ class Registry:
                                     "res_id": "unilabos_resources",  # 将当前实验室的全部物料id作为下拉框可选择
                                     "device_id": "unilabos_devices",  # 将当前实验室的全部设备id作为下拉框可选择
                                     "parent": "unilabos_nodes",  # 将当前实验室的设备/物料作为下拉框可选择
-                                    "class_name": "unilabos_class",
                                 },
                             },
                             "test_latency": {
@@ -266,7 +265,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
@@ -260,7 +260,7 @@ def read_node_link_json(
     resource_tree_set = canonicalize_nodes_data(nodes)
 
     # 标准化边数据
-    links = data.get("links", data.get("edges", []))
+    links = data.get("links", [])
     standardized_links = canonicalize_links_ports(links, resource_tree_set)
 
     # 构建 NetworkX 图（需要转换回 dict 格式）

unilabos/resources/resource_tracker.py

@@ -13,9 +13,6 @@ if TYPE_CHECKING:
     from pylabrobot.resources import Resource as PLRResource
 
 
-EXTRA_CLASS = "unilabos_resource_class"
-
-
 class ResourceDictPositionSize(BaseModel):
     depth: float = Field(description="Depth", default=0.0)  # z
     width: float = Field(description="Width", default=0.0)  # x
@@ -69,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")
+    data: Dict[str, Any] = Field(description="Resource data, eg: container liquid data")
-    extra: Dict[str, Any] = Field(description="Extra data")
+    extra: Dict[str, Any] = Field(description="Extra data, eg: slot index")
 
     @field_serializer("parent_uuid")
     def _serialize_parent(self, parent_uuid: Optional["ResourceDict"]):
@@ -396,7 +393,7 @@ class ResourceTreeSet(object):
                 "parent": parent_resource,  # 直接传入 ResourceDict 对象
                 "parent_uuid": parent_uuid,  # 使用 parent_uuid 而不是 parent 对象
                 "type": replace_plr_type(d.get("category", "")),
-                "class": extra.get(EXTRA_CLASS, ""),
+                "class": d.get("class", ""),
                 "position": pos,
                 "pose": pos,
                 "config": {
@@ -446,7 +443,7 @@ class ResourceTreeSet(object):
             trees.append(tree_instance)
         return cls(trees)
 
-    def to_plr_resources(self, skip_devices=True) -> List["PLRResource"]:
+    def to_plr_resources(self) -> List["PLRResource"]:
         """
         将 ResourceTreeSet 转换为 PLR 资源列表
 
@@ -471,7 +468,6 @@ class ResourceTreeSet(object):
             name_to_uuid[node.res_content.name] = node.res_content.uuid
             all_states[node.res_content.name] = node.res_content.data
             name_to_extra[node.res_content.name] = node.res_content.extra
-            name_to_extra[node.res_content.name][EXTRA_CLASS] = node.res_content.klass
             for child in node.children:
                 collect_node_data(child, name_to_uuid, all_states, name_to_extra)
 
@@ -516,10 +512,7 @@ class ResourceTreeSet(object):
             plr_dict = node_to_plr_dict(tree.root_node, has_model)
             try:
                 sub_cls = find_subclass(plr_dict["type"], PLRResource)
-                if skip_devices and plr_dict["type"] == "device":
+                if sub_cls is None:
-                    logger.info(f"跳过更新 {plr_dict['name']} 设备是class")
-                    continue
-                elif sub_cls is None:
                     raise ValueError(
                         f"无法找到类型 {plr_dict['type']} 对应的 PLR 资源类。原始信息：{tree.root_node.res_content}"
                     )
@@ -527,10 +520,6 @@ class ResourceTreeSet(object):
                 if "category" not in spec.parameters:
                     plr_dict.pop("category", None)
                 plr_resource = sub_cls.deserialize(plr_dict, allow_marshal=True)
-                from pylabrobot.resources import Coordinate
-                from pylabrobot.serializer import deserialize
-                location = cast(Coordinate, deserialize(plr_dict["location"]))
-                plr_resource.location = location
                 plr_resource.load_all_state(all_states)
                 # 使用 DeviceNodeResourceTracker 设置 UUID 和 Extra
                 tracker.loop_set_uuid(plr_resource, name_to_uuid)
@@ -997,7 +986,7 @@ class DeviceNodeResourceTracker(object):
                 extra = name_to_extra_map[resource_name]
                 self.set_resource_extra(res, extra)
                 if len(extra):
-                    logger.trace(f"设置资源Extra: {resource_name} -> {extra}")
+                    logger.debug(f"设置资源Extra: {resource_name} -> {extra}")
                 return 1
             return 0
 

unilabos/ros/nodes/base_device_node.py

@@ -884,9 +884,6 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                                 parent_appended = True
 
                 # 加载状态
-                original_instance.location = plr_resource.location
-                original_instance.rotation = plr_resource.rotation
-                original_instance.barcode = plr_resource.barcode
                 original_instance.load_all_state(states)
                 child_count = len(original_instance.get_all_children())
                 self.lab_logger().info(

unilabos/ros/nodes/presets/workstation.py

@@ -6,6 +6,8 @@ from typing import List, Dict, Any, Optional, TYPE_CHECKING
 
 import rclpy
 from rosidl_runtime_py import message_to_ordereddict
+from unilabos_msgs.msg import Resource
+from unilabos_msgs.srv import ResourceUpdate
 
 from unilabos.messages import *  # type: ignore  # protocol names
 from rclpy.action import ActionServer, ActionClient
@@ -13,6 +15,7 @@ from rclpy.action.server import ServerGoalHandle
 from unilabos_msgs.srv._serial_command import SerialCommand_Request, SerialCommand_Response
 
 from unilabos.compile import action_protocol_generators
+from unilabos.resources.graphio import nested_dict_to_list
 from unilabos.ros.initialize_device import initialize_device_from_dict
 from unilabos.ros.msgs.message_converter import (
     get_action_type,
@@ -228,15 +231,15 @@ class ROS2WorkstationNode(BaseROS2DeviceNode):
                         try:
                             # 统一处理单个或多个资源
                             resource_id = (
-                                protocol_kwargs[k]["id"]
+                                protocol_kwargs[k]["id"] if v == "unilabos_msgs/Resource" else protocol_kwargs[k][0]["id"]
-                                if v == "unilabos_msgs/Resource"
-                                else protocol_kwargs[k][0]["id"]
                             )
                             resource_uuid = protocol_kwargs[k].get("uuid", None)
                             r = SerialCommand_Request()
                             r.command = json.dumps({"id": resource_id, "uuid": resource_uuid, "with_children": True})
                             # 发送请求并等待响应
-                            response: SerialCommand_Response = await self._resource_clients["resource_get"].call_async(
+                            response: SerialCommand_Response = await self._resource_clients[
+                                "resource_get"
+                            ].call_async(
                                 r
                             )  # type: ignore
                             raw_data = json.loads(response.response)
@@ -304,52 +307,12 @@ class ROS2WorkstationNode(BaseROS2DeviceNode):
 
                 # 向Host更新物料当前状态
                 for k, v in goal.get_fields_and_field_types().items():
-                    if v not in ["unilabos_msgs/Resource", "sequence<unilabos_msgs/Resource>"]:
+                    if v in ["unilabos_msgs/Resource", "sequence<unilabos_msgs/Resource>"]:
-                        continue
+                        r = ResourceUpdate.Request()
-                    self.lab_logger().info(f"更新资源状态: {k}")
+                        r.resources = [
-                    try:
+                            convert_to_ros_msg(Resource, rs) for rs in nested_dict_to_list(protocol_kwargs[k])
-                        # 去重：使用 seen 集合获取唯一的资源对象
+                        ]
-                        seen = set()
+                        response = await self._resource_clients["resource_update"].call_async(r)
-                        unique_resources = []
-
-                        # 获取资源数据，统一转换为列表
-                        resource_data = protocol_kwargs[k]
-                        is_sequence = v != "unilabos_msgs/Resource"
-                        if not is_sequence:
-                            resource_list = [resource_data] if isinstance(resource_data, dict) else resource_data
-                        else:
-                            # 处理序列类型，可能是嵌套列表
-                            resource_list = []
-                            if isinstance(resource_data, list):
-                                for item in resource_data:
-                                    if isinstance(item, list):
-                                        resource_list.extend(item)
-                                    else:
-                                        resource_list.append(item)
-                            else:
-                                resource_list = [resource_data]
-
-                        for res_data in resource_list:
-                            if not isinstance(res_data, dict):
-                                continue
-                            res_name = res_data.get("id") or res_data.get("name")
-                            if not res_name:
-                                continue
-
-                            # 使用 resource_tracker 获取本地 PLR 实例
-                            plr = self.resource_tracker.figure_resource({"name": res_name}, try_mode=False)
-                            # 获取父资源
-                            res = self.resource_tracker.parent_resource(plr)
-                            if id(res) not in seen:
-                                seen.add(id(res))
-                                unique_resources.append(res)
-
-                        # 使用新的资源树接口更新
-                        if unique_resources:
-                            await self.update_resource(unique_resources)
-                    except Exception as e:
-                        self.lab_logger().error(f"资源更新失败: {e}")
-                        self.lab_logger().error(traceback.format_exc())
 
                 # 设置成功状态和返回值
                 execution_success = True

unilabos/workflow/common.py

@@ -1,89 +1,3 @@
-"""
-工作流转换模块 - JSON 到 WorkflowGraph 的转换流程
-
-==================== 输入格式 (JSON) ====================
-
-{
-    "workflow": [
-        {"action": "transfer_liquid", "action_args": {"sources": "cell_lines", "targets": "Liquid_1", "asp_vol": 100.0, "dis_vol": 74.75, ...}},
-        ...
-    ],
-    "reagent": {
-        "cell_lines": {"slot": 4, "well": ["A1", "A3", "A5"], "labware": "DRUG + YOYO-MEDIA"},
-        "Liquid_1": {"slot": 1, "well": ["A4", "A7", "A10"], "labware": "rep 1"},
-        ...
-    }
-}
-
-==================== 转换步骤 ====================
-
-第一步: 按 slot 去重创建 create_resource 节点（创建板子）
---------------------------------------------------------------------------------
-- 遍历所有 reagent，按 slot 去重，为每个唯一的 slot 创建一个板子
-- 生成参数:
-    res_id: plate_slot_{slot}
-    device_id: /PRCXI
-    class_name: PRCXI_BioER_96_wellplate
-    parent: /PRCXI/PRCXI_Deck/T{slot}
-    slot_on_deck: "{slot}"
-- 输出端口: labware（用于连接 set_liquid_from_plate）
-- 控制流: create_resource 之间通过 ready 端口串联
-
-示例: slot=1, slot=4 -> 创建 2 个 create_resource 节点
-
-第二步: 为每个 reagent 创建 set_liquid_from_plate 节点（设置液体）
---------------------------------------------------------------------------------
-- 遍历所有 reagent，为每个试剂创建 set_liquid_from_plate 节点
-- 生成参数:
-    plate: []（通过连接传递，来自 create_resource 的 labware）
-    well_names: ["A1", "A3", "A5"]（来自 reagent 的 well 数组）
-    liquid_names: ["cell_lines", "cell_lines", "cell_lines"]（与 well 数量一致）
-    volumes: [1e5, 1e5, 1e5]（与 well 数量一致，默认体积）
-- 输入连接: create_resource (labware) -> set_liquid_from_plate (input_plate)
-- 输出端口: output_wells（用于连接 transfer_liquid）
-- 控制流: set_liquid_from_plate 连接在所有 create_resource 之后，通过 ready 端口串联
-
-第三步: 解析 workflow，创建 transfer_liquid 等动作节点
---------------------------------------------------------------------------------
-- 遍历 workflow 数组，为每个动作创建步骤节点
-- 参数重命名: asp_vol -> asp_vols, dis_vol -> dis_vols, asp_flow_rate -> asp_flow_rates, dis_flow_rate -> dis_flow_rates
-- 参数扩展: 根据 targets 的 wells 数量，将单值扩展为数组
-    例: asp_vol=100.0, targets 有 3 个 wells -> asp_vols=[100.0, 100.0, 100.0]
-- 连接处理: 如果 sources/targets 已通过 set_liquid_from_plate 连接，参数值改为 []
-- 输入连接: set_liquid_from_plate (output_wells) -> transfer_liquid (sources_identifier / targets_identifier)
-- 输出端口: sources_out, targets_out（用于连接下一个 transfer_liquid）
-
-==================== 连接关系图 ====================
-
-控制流 (ready 端口串联):
-    create_resource_1 -> create_resource_2 -> ... -> set_liquid_1 -> set_liquid_2 -> ... -> transfer_liquid_1 -> transfer_liquid_2 -> ...
-
-物料流:
-    [create_resource] --labware--> [set_liquid_from_plate] --output_wells--> [transfer_liquid] --sources_out/targets_out--> [下一个 transfer_liquid]
-          (slot=1)                    (cell_lines)           (input_plate)     (sources_identifier)                          (sources_identifier)
-          (slot=4)                    (Liquid_1)                               (targets_identifier)                          (targets_identifier)
-
-==================== 端口映射 ====================
-
-create_resource:
-    输出: labware
-
-set_liquid_from_plate:
-    输入: input_plate
-    输出: output_plate, output_wells
-
-transfer_liquid:
-    输入: sources -> sources_identifier, targets -> targets_identifier
-    输出: sources -> sources_out, targets -> targets_out
-
-==================== 校验规则 ====================
-
-- 检查 sources/targets 是否在 reagent 中定义
-- 检查 sources 和 targets 的 wells 数量是否匹配
-- 检查参数数组长度是否与 wells 数量一致
-- 如有问题，在 footer 中添加 [WARN: ...] 标记
-"""
-
 import re
 import uuid
 
@@ -94,28 +8,6 @@ from typing import Dict, List, Any, Tuple, Optional
 
 Json = Dict[str, Any]
 
-
-# ==================== 默认配置 ====================
-
-# create_resource 节点默认参数
-CREATE_RESOURCE_DEFAULTS = {
-    "device_id": "/PRCXI",
-    "parent_template": "/PRCXI/PRCXI_Deck/T{slot}",  # {slot} 会被替换为实际的 slot 值
-    "class_name": "PRCXI_BioER_96_wellplate",
-}
-
-# 默认液体体积 (uL)
-DEFAULT_LIQUID_VOLUME = 1e5
-
-# 参数重命名映射：单数 -> 复数（用于 transfer_liquid 等动作）
-PARAM_RENAME_MAPPING = {
-    "asp_vol": "asp_vols",
-    "dis_vol": "dis_vols",
-    "asp_flow_rate": "asp_flow_rates",
-    "dis_flow_rate": "dis_flow_rates",
-}
-
-
 # ---------------- Graph ----------------
 
 
@@ -336,7 +228,7 @@ def refactor_data(
 
 
 def build_protocol_graph(
-    labware_info: Dict[str, Dict[str, Any]],
+    labware_info: List[Dict[str, Any]],
     protocol_steps: List[Dict[str, Any]],
     workstation_name: str,
     action_resource_mapping: Optional[Dict[str, str]] = None,
@@ -344,227 +236,112 @@ def build_protocol_graph(
     """统一的协议图构建函数，根据设备类型自动选择构建逻辑
 
     Args:
-        labware_info: labware 信息字典，格式为 {name: {slot, well, labware, ...}, ...}
+        labware_info: labware 信息字典
         protocol_steps: 协议步骤列表
         workstation_name: 工作站名称
         action_resource_mapping: action 到 resource_name 的映射字典，可选
     """
     G = WorkflowGraph()
-    resource_last_writer = {}  # reagent_name -> "node_id:port"
+    resource_last_writer = {}
-    slot_to_create_resource = {}  # slot -> create_resource node_id
 
     protocol_steps = refactor_data(protocol_steps, action_resource_mapping)
+    # 有机化学&移液站协议图构建
+    WORKSTATION_ID = workstation_name
 
-    # ==================== 第一步：按 slot 去重创建 create_resource 节点 ====================
+    # 为所有labware创建资源节点
-    # 收集所有唯一的 slot
-    slots_info = {}  # slot -> {labware, res_id}
-    for labware_id, item in labware_info.items():
-        slot = str(item.get("slot", ""))
-        if slot and slot not in slots_info:
-            res_id = f"plate_slot_{slot}"
-            slots_info[slot] = {
-                "labware": item.get("labware", ""),
-                "res_id": res_id,
-            }
-
-    # 为每个唯一的 slot 创建 create_resource 节点
     res_index = 0
-    last_create_resource_id = None
+    for labware_id, item in labware_info.items():
-    for slot, info in slots_info.items():
+        # item_id = item.get("id") or item.get("name", f"item_{uuid.uuid4()}")
         node_id = str(uuid.uuid4())
-        res_id = info["res_id"]
+
+        # 判断节点类型
+        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"Plate {res_index}",
+            name=f"Res {res_index}",
-            description=f"Create plate on slot {slot}",
+            description=description,
-            lab_node_type="Labware",
+            lab_node_type=lab_node_type,
             footer="create_resource-host_node",
             param={
-                "res_id": res_id,
+                "res_id": labware_id,
-                "device_id": CREATE_RESOURCE_DEFAULTS["device_id"],
+                "device_id": WORKSTATION_ID,
-                "class_name": CREATE_RESOURCE_DEFAULTS["class_name"],
+                "class_name": "container",
-                "parent": CREATE_RESOURCE_DEFAULTS["parent_template"].format(slot=slot),
+                "parent": WORKSTATION_ID,
                 "bind_locations": {"x": 0.0, "y": 0.0, "z": 0.0},
-                "slot_on_deck": slot,
+                "liquid_input_slot": [-1],
+                "liquid_type": liquid_type,
+                "liquid_volume": liquid_volume,
+                "slot_on_deck": "",
             },
         )
-        slot_to_create_resource[slot] = node_id
+        resource_last_writer[labware_id] = f"{node_id}:labware"
 
-        # create_resource 之间通过 ready 串联
+    last_control_node_id = None
-        if last_create_resource_id is not None:
-            G.add_edge(last_create_resource_id, node_id, source_port="ready", target_port="ready")
-        last_create_resource_id = node_id
-
-    # ==================== 第二步：为每个 reagent 创建 set_liquid_from_plate 节点 ====================
-    set_liquid_index = 0
-    last_set_liquid_id = last_create_resource_id  # set_liquid_from_plate 连接在 create_resource 之后
-
-    for labware_id, item in labware_info.items():
-        # 跳过 Tip/Rack 类型
-        if "Rack" in str(labware_id) or "Tip" in str(labware_id):
-            continue
-        if item.get("type") == "hardware":
-            continue
-
-        slot = str(item.get("slot", ""))
-        wells = item.get("well", [])
-        if not wells or not slot:
-            continue
-
-        # res_id 不能有空格
-        res_id = str(labware_id).replace(" ", "_")
-        well_count = len(wells)
-
-        node_id = str(uuid.uuid4())
-        set_liquid_index += 1
-
-        G.add_node(
-            node_id,
-            template_name="set_liquid_from_plate",
-            resource_name="liquid_handler.prcxi",
-            name=f"SetLiquid {set_liquid_index}",
-            description=f"Set liquid: {labware_id}",
-            lab_node_type="Reagent",
-            footer="set_liquid_from_plate-liquid_handler.prcxi",
-            param={
-                "plate": [],  # 通过连接传递
-                "well_names": wells,  # 孔位名数组，如 ["A1", "A3", "A5"]
-                "liquid_names": [res_id] * well_count,
-                "volumes": [DEFAULT_LIQUID_VOLUME] * well_count,
-            },
-        )
-
-        # ready 连接：上一个节点 -> set_liquid_from_plate
-        if last_set_liquid_id is not None:
-            G.add_edge(last_set_liquid_id, node_id, source_port="ready", target_port="ready")
-        last_set_liquid_id = node_id
-
-        # 物料流：create_resource 的 labware -> set_liquid_from_plate 的 input_plate
-        create_res_node_id = slot_to_create_resource.get(slot)
-        if create_res_node_id:
-            G.add_edge(create_res_node_id, node_id, source_port="labware", target_port="input_plate")
-
-        # set_liquid_from_plate 的输出 output_wells 用于连接 transfer_liquid
-        resource_last_writer[labware_id] = f"{node_id}:output_wells"
-
-    last_control_node_id = last_set_liquid_id
-
-    # 端口名称映射：JSON 字段名 -> 实际 handle key
-    INPUT_PORT_MAPPING = {
-        "sources": "sources_identifier",
-        "targets": "targets_identifier",
-        "vessel": "vessel",
-        "to_vessel": "to_vessel",
-        "from_vessel": "from_vessel",
-        "reagent": "reagent",
-        "solvent": "solvent",
-        "compound": "compound",
-    }
-
-    OUTPUT_PORT_MAPPING = {
-        "sources": "sources_out",  # 输出端口是 xxx_out
-        "targets": "targets_out",  # 输出端口是 xxx_out
-        "vessel": "vessel_out",
-        "to_vessel": "to_vessel_out",
-        "from_vessel": "from_vessel_out",
-        "filtrate_vessel": "filtrate_out",
-        "reagent": "reagent",
-        "solvent": "solvent",
-        "compound": "compound",
-    }
-
-    # 需要根据 wells 数量扩展的参数列表（复数形式）
-    EXPAND_BY_WELLS_PARAMS = ["asp_vols", "dis_vols", "asp_flow_rates", "dis_flow_rates"]
 
     # 处理协议步骤
     for step in protocol_steps:
         node_id = str(uuid.uuid4())
-        params = step.get("param", {}).copy()  # 复制一份，避免修改原数据
+        G.add_node(node_id, **step)
-        connected_params = set()  # 记录被连接的参数
-        warnings = []  # 收集警告信息
-
-        # 参数重命名：单数 -> 复数
-        for old_name, new_name in PARAM_RENAME_MAPPING.items():
-            if old_name in params:
-                params[new_name] = params.pop(old_name)
-
-        # 处理输入连接
-        for param_key, target_port in INPUT_PORT_MAPPING.items():
-            resource_name = params.get(param_key)
-            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)
-                connected_params.add(param_key)
-            elif resource_name and resource_name not in resource_last_writer:
-                # 资源名在 labware_info 中不存在
-                warnings.append(f"{param_key}={resource_name} 未找到")
-
-        # 获取 targets 对应的 wells 数量，用于扩展参数
-        targets_name = params.get("targets")
-        sources_name = params.get("sources")
-        targets_wells_count = 1
-        sources_wells_count = 1
-
-        if targets_name and targets_name in labware_info:
-            target_wells = labware_info[targets_name].get("well", [])
-            targets_wells_count = len(target_wells) if target_wells else 1
-        elif targets_name:
-            warnings.append(f"targets={targets_name} 未在 reagent 中定义")
-
-        if sources_name and sources_name in labware_info:
-            source_wells = labware_info[sources_name].get("well", [])
-            sources_wells_count = len(source_wells) if source_wells else 1
-        elif sources_name:
-            warnings.append(f"sources={sources_name} 未在 reagent 中定义")
-
-        # 检查 sources 和 targets 的 wells 数量是否匹配
-        if targets_wells_count != sources_wells_count and targets_name and sources_name:
-            warnings.append(f"wells 数量不匹配: sources={sources_wells_count}, targets={targets_wells_count}")
-
-        # 使用 targets 的 wells 数量来扩展参数
-        wells_count = targets_wells_count
-
-        # 扩展单值参数为数组（根据 targets 的 wells 数量）
-        for expand_param in EXPAND_BY_WELLS_PARAMS:
-            if expand_param in params:
-                value = params[expand_param]
-                # 如果是单个值，扩展为数组
-                if not isinstance(value, list):
-                    params[expand_param] = [value] * wells_count
-                # 如果已经是数组但长度不对，记录警告
-                elif len(value) != wells_count:
-                    warnings.append(f"{expand_param} 数量({len(value)})与 wells({wells_count})不匹配")
-
-        # 如果 sources/targets 已通过连接传递，将参数值改为空数组
-        for param_key in connected_params:
-            if param_key in params:
-                params[param_key] = []
-
-        # 更新 step 的 param 和 footer
-        step_copy = step.copy()
-        step_copy["param"] = params
-
-        # 如果有警告，修改 footer 添加警告标记（警告放前面）
-        if warnings:
-            original_footer = step.get("footer", "")
-            step_copy["footer"] = f"[WARN: {'; '.join(warnings)}] {original_footer}"
-
-        G.add_node(node_id, **step_copy)
 
         # 控制流
         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
 
-        # 处理输出：更新 resource_last_writer
+        # 物料流
-        for param_key, output_port in OUTPUT_PORT_MAPPING.items():
+        params = step.get("param", {})
-            resource_name = step.get("param", {}).get(param_key)  # 使用原始参数值
+        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}:{output_port}"
+                resource_last_writer[resource_name] = f"{node_id}:{source_port}"
 
     return G
 

unilabos/workflow/convert_from_json.py

@@ -1,68 +1,21 @@
 """
 JSON 工作流转换模块
 
-将 workflow/reagent 格式的 JSON 转换为统一工作流格式。
+提供从多种 JSON 格式转换为统一工作流格式的功能。
-
+支持的格式：
-输入格式:
+1. workflow/reagent 格式
-{
+2. steps_info/labware_info 格式
-    "workflow": [
-        {"action": "...", "action_args": {...}},
-        ...
-    ],
-    "reagent": {
-        "reagent_name": {"slot": int, "well": [...], "labware": "..."},
-        ...
-    }
-}
 """
 
 import json
 from os import PathLike
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union
+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
 
 
-# ==================== 字段映射配置 ====================
-
-# 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",
-}
-
-# action_args 字段到 parameters 字段的映射
-# 格式: {"old_key": "new_key"}, 仅映射需要重命名的字段
-ARGS_FIELD_MAPPING: Dict[str, str] = {
-    # 如果需要字段重命名，在这里配置
-    # "old_field_name": "new_field_name",
-}
-
-# 默认工作站名称
-DEFAULT_WORKSTATION = "PRCXI"
-
-
-# ==================== 核心转换函数 ====================
-
-
 def get_action_handles(resource_name: str, template_name: str) -> Dict[str, List[str]]:
     """
     从 registry 获取指定设备和动作的 handles 配置
@@ -86,10 +39,12 @@ def get_action_handles(resource_name: str, template_name: str) -> Dict[str, List
     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:
@@ -114,9 +69,12 @@ def validate_workflow_handles(graph: WorkflowGraph) -> Tuple[bool, List[str]]:
     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, {})
 
@@ -125,93 +83,164 @@ def validate_workflow_handles(graph: WorkflowGraph) -> Tuple[bool, List[str]]:
         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")
 
-        # 验证目标节点（right）的输入端口
+        # 如果节点配置了 output handles，则 source_port 必须有效
         if not right_source_conn_key:
-            node_name = right_node.get("name", right_uuid[:8])
+            node_name = left_node.get("name", left_uuid[:8])
-            errors.append(f"目标节点 '{node_name}' 的输入端口 (target_handle_key) 为空，应设置为: {source_valid_keys}")
+            errors.append(f"源节点 '{node_name}' 的 source_handle_key 为空，" f"应设置为: {source_valid_keys}")
         elif right_source_conn_key not in source_valid_keys:
-            node_name = right_node.get("name", right_uuid[:8])
+            node_name = left_node.get("name", left_uuid[:8])
             errors.append(
-                f"目标节点 '{node_name}' 的输入端口 '{right_source_conn_key}' 不存在，支持的输入端口: {source_valid_keys}"
+                f"源节点 '{node_name}' 的 source 端点 '{right_source_conn_key}' 不存在，" f"支持的端点: {source_valid_keys}"
             )
 
-        # 验证源节点（left）的输出端口
+        # 如果节点配置了 input handles，则 target_port 必须有效
         if not left_target_conn_key:
-            node_name = left_node.get("name", left_uuid[:8])
+            node_name = right_node.get("name", right_uuid[:8])
-            errors.append(f"源节点 '{node_name}' 的输出端口 (source_handle_key) 为空，应设置为: {target_valid_keys}")
+            errors.append(f"目标节点 '{node_name}' 的 target_handle_key 为空，" f"应设置为: {target_valid_keys}")
         elif left_target_conn_key not in target_valid_keys:
-            node_name = left_node.get("name", left_uuid[:8])
+            node_name = right_node.get("name", right_uuid[:8])
             errors.append(
-                f"源节点 '{node_name}' 的输出端口 '{left_target_conn_key}' 不存在，支持的输出端口: {target_valid_keys}"
+                f"目标节点 '{node_name}' 的 target 端点 '{left_target_conn_key}' 不存在，"
+                f"支持的端点: {target_valid_keys}"
             )
 
     return len(errors) == 0, errors
 
 
-def normalize_workflow_steps(workflow: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+# 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]]:
     """
-    将 workflow 格式的步骤数据规范化
+    将不同格式的步骤数据规范化为统一格式
 
-    输入格式:
+    支持的输入格式：
-        [{"action": "...", "action_args": {...}}, ...]
+    - action + parameters
-
+    - action + action_args
-    输出格式:
+    - operation + parameters
-        [{"action": "...", "parameters": {...}, "step_number": int}, ...]
 
     Args:
-        workflow: workflow 数组
+        data: 原始步骤数据列表
 
     Returns:
-        规范化后的步骤列表
+        规范化后的步骤列表，格式为 [{"action": str, "parameters": dict, "description": str?, "step_number": int?}, ...]
     """
     normalized = []
-    for idx, step in enumerate(workflow):
+    for idx, step in enumerate(data):
-        action = step.get("action")
+        # 获取动作名称（支持 action 或 operation 字段）
+        action = step.get("action") or step.get("operation")
         if not action:
             continue
 
-        # 获取参数: action_args
+        # 获取参数（支持 parameters 或 action_args 字段）
-        raw_params = step.get("action_args", {})
+        raw_params = step.get("parameters") or step.get("action_args") or {}
-        params = {}
+        params = dict(raw_params)
 
-        # 应用字段映射
+        # 规范化 source/target -> sources/targets
-        for key, value in raw_params.items():
+        if "source" in raw_params and "sources" not in raw_params:
-            mapped_key = ARGS_FIELD_MAPPING.get(key, key)
+            params["sources"] = raw_params["source"]
-            params[mapped_key] = value
+        if "target" in raw_params and "targets" not in raw_params:
+            params["targets"] = raw_params["target"]
 
-        step_dict = {
+        # 获取描述（支持 description 或 purpose 字段）
-            "action": action,
+        description = step.get("description") or step.get("purpose")
-            "parameters": params,
-            "step_number": idx + 1,
-        }
 
-        # 保留描述字段
+        # 获取步骤编号（优先使用原始数据中的 step_number，否则使用索引+1）
-        if "description" in step:
+        step_number = step.get("step_number", idx + 1)
-            step_dict["description"] = step["description"]
+
+        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 = DEFAULT_WORKSTATION,
+    workstation_name: str = "PRCXi",
     validate: bool = True,
 ) -> WorkflowGraph:
     """
     从 JSON 数据或文件转换为 WorkflowGraph
 
-    JSON 格式:
+    支持的 JSON 格式：
-        {"workflow": [...], "reagent": {...}}
+    1. {"workflow": [...], "reagent": {...}} - 直接格式
+    2. {"steps_info": [...], "labware_info": [...]} - 需要规范化的格式
 
     Args:
         data: JSON 文件路径、字典数据、或 JSON 字符串
@@ -222,7 +251,7 @@ def convert_from_json(
         WorkflowGraph: 构建好的工作流图
 
     Raises:
-        ValueError: 不支持的 JSON 格式
+        ValueError: 不支持的 JSON 格式 或 句柄校验失败
         FileNotFoundError: 文件不存在
         json.JSONDecodeError: JSON 解析失败
     """
@@ -233,6 +262,7 @@ def convert_from_json(
             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}")
@@ -241,24 +271,30 @@ def convert_from_json(
     else:
         raise TypeError(f"不支持的数据类型: {type(data)}")
 
-    # 校验格式
+    # 根据格式解析数据
-    if "workflow" not in json_data or "reagent" not in json_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"
+            "不支持的 JSON 格式。支持的格式：\n"
-            '{"workflow": [{"action": "...", "action_args": {...}}, ...], '
+            "1. {'workflow': [...], 'reagent': {...}}\n"
-            '"reagent": {"name": {"slot": int, "well": [...], "labware": "..."}, ...}}'
+            "2. {'steps_info': [...], 'labware_info': [...]}\n"
+            "3. {'steps': [...], 'labware': [...]}"
         )
 
-    # 提取数据
-    workflow = json_data["workflow"]
-    reagent = json_data["reagent"]
-
-    # 规范化步骤数据
-    protocol_steps = normalize_workflow_steps(workflow)
-
-    # reagent 已经是字典格式，直接使用
-    labware_info = reagent
-
     # 构建工作流图
     graph = build_protocol_graph(
         labware_info=labware_info,
@@ -281,7 +317,7 @@ def convert_from_json(
 
 def convert_json_to_node_link(
     data: Union[str, PathLike, Dict[str, Any]],
-    workstation_name: str = DEFAULT_WORKSTATION,
+    workstation_name: str = "PRCXi",
 ) -> Dict[str, Any]:
     """
     将 JSON 数据转换为 node-link 格式的字典
@@ -299,7 +335,7 @@ def convert_json_to_node_link(
 
 def convert_json_to_workflow_list(
     data: Union[str, PathLike, Dict[str, Any]],
-    workstation_name: str = DEFAULT_WORKSTATION,
+    workstation_name: str = "PRCXi",
 ) -> List[Dict[str, Any]]:
     """
     将 JSON 数据转换为工作流列表格式
@@ -313,3 +349,8 @@ def convert_json_to_workflow_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/workflow/legacy/convert_from_json_legacy.py

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