workflow upload & set liquid fix & add set liquid with plate

fix upload workflow json

save class name when deserialize & protocol execute test

Support root node change pos

add unilabos_class

gather query

.conda/base/recipe.yaml

@@ -46,7 +46,7 @@ requirements:
   - jinja2
   - requests
   - uvicorn
-  - opcua # [not osx]
+  - opcua
   - pyserial
   - pandas
   - pymodbus

docs/user_guide/best_practice.md

@@ -452,9 +452,8 @@ unilab --ak your_ak --sk your_sk -g test/experiments/mock_devices/mock_all.json
 **操作步骤：**
 
 1. 将两个 `container` 拖拽到 `workstation` 中
-2. 将 `virtual_multiway_valve` 拖拽到 `workstation` 中
+2. 将 `virtual_transfer_pump` 拖拽到 `workstation` 中
-3. 将 `virtual_transfer_pump` 拖拽到 `workstation` 中
+3. 在画布上连接它们（建立父子关系）
-4. 在画布上连接它们（建立父子关系）
 
 ![设备连接](image/links.png)
 

scripts/workflow.py

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

unilabos/app/model.py

@@ -54,7 +54,6 @@ class JobAddReq(BaseModel):
     action_type: str = Field(
         examples=["unilabos_msgs.action._str_single_input.StrSingleInput"], description="action type", default=""
     )
-    sample_material: dict = Field(examples=[{"string": "string"}], description="sample uuid to material uuid")
     action_args: dict = Field(examples=[{"string": "string"}], description="action arguments", default_factory=dict)
     task_id: str = Field(examples=["task_id"], description="task uuid (auto-generated if empty)", default="")
     job_id: str = Field(examples=["job_id"], description="goal uuid (auto-generated if empty)", default="")

unilabos/app/web/controller.py

@@ -327,7 +327,6 @@ def job_add(req: JobAddReq) -> JobData:
             queue_item,
             action_type=action_type,
             action_kwargs=action_args,
-            sample_material=req.sample_material,
             server_info=server_info,
         )
 

unilabos/app/ws_client.py

@@ -439,7 +439,7 @@ class MessageProcessor:
                     self.connected = True
                     self.reconnect_count = 0
 
-                    logger.trace(f"[MessageProcessor] Connected to {self.websocket_url}")
+                    logger.info(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.trace("[MessageProcessor] Send handler started")
+        logger.debug("[MessageProcessor] Send handler started")
 
         try:
             while self.connected and self.websocket:
@@ -545,7 +545,7 @@ class MessageProcessor:
                         try:
                             message_str = json.dumps(msg, ensure_ascii=False)
                             await self.websocket.send(message_str)
-                            # logger.trace(f"[MessageProcessor] Message sent: {msg.get('action', 'unknown')}")  # type: ignore  # noqa: E501
+                            logger.trace(f"[MessageProcessor] Message sent: {msg.get('action', 'unknown')}")  # type: ignore  # noqa: E501
                         except Exception as e:
                             logger.error(f"[MessageProcessor] Failed to send message: {str(e)}")
                             logger.error(traceback.format_exc())
@@ -657,8 +657,6 @@ class MessageProcessor:
     async def _handle_job_start(self, data: Dict[str, Any]):
         """处理job_start消息"""
         try:
-            if not data.get("sample_material"):
-                data["sample_material"] = {}
             req = JobAddReq(**data)
 
             job_log = format_job_log(req.job_id, req.task_id, req.device_id, req.action)
@@ -690,7 +688,6 @@ class MessageProcessor:
                 queue_item,
                 action_type=req.action_type,
                 action_kwargs=req.action_args,
-                sample_material=req.sample_material,
                 server_info=req.server_info,
             )
 
@@ -1029,7 +1026,7 @@ class QueueProcessor:
 
     def _run(self):
         """运行队列处理主循环"""
-        logger.trace("[QueueProcessor] Queue processor started")
+        logger.debug("[QueueProcessor] Queue processor started")
 
         while self.is_running:
             try:
@@ -1239,6 +1236,7 @@ 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:
@@ -1251,11 +1249,13 @@ 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.trace("[WebSocketClient] All threads started")
+        logger.info("[WebSocketClient] All threads started")
 
     def stop(self) -> None:
         """停止WebSocket客户端"""
@@ -1304,7 +1304,7 @@ class WebSocketClient(BaseCommunicationClient):
             },
         }
         self.message_processor.send_message(message)
-        # logger.trace(f"[WebSocketClient] Device status published: {device_id}.{property_name}")
+        logger.trace(f"[WebSocketClient] Device status published: {device_id}.{property_name}")
 
     def publish_job_status(
         self, feedback_data: dict, item: QueueItem, status: str, return_info: Optional[dict] = None

unilabos/compile/pump_protocol.py

@@ -95,29 +95,8 @@ def get_vessel_liquid_volume(G: nx.DiGraph, vessel: str) -> float:
     return total_volume
 
 
-def is_integrated_pump(node_class: str, node_name: str = "") -> bool:
+def is_integrated_pump(node_name):
-    """
+    return "pump" in node_name and "valve" in node_name
-    判断是否为泵阀一体设备
-    """
-    class_lower = (node_class or "").lower()
-    name_lower = (node_name or "").lower()
-
-    if "pump" not in class_lower and "pump" not in name_lower:
-        return False
-
-    integrated_markers = [
-        "valve",
-        "pump_valve",
-        "pumpvalve",
-        "integrated",
-        "transfer_pump",
-    ]
-
-    for marker in integrated_markers:
-        if marker in class_lower or marker in name_lower:
-            return True
-
-    return False
 
 
 def find_connected_pump(G, valve_node):
@@ -207,9 +186,7 @@ def build_pump_valve_maps(G, pump_backbone):
     debug_print(f"🔧 过滤后的骨架: {filtered_backbone}")
 
     for node in filtered_backbone:
-        node_data = G.nodes.get(node, {})
+        if is_integrated_pump(G.nodes[node]["class"]):
-        node_class = node_data.get("class", "") or ""
-        if is_integrated_pump(node_class, node):
             pumps_from_node[node] = node
             valve_from_node[node] = node
             debug_print(f"  - 集成泵-阀: {node}")

unilabos/devices/liquid_handling/liquid_handler_abstract.py

@@ -1,11 +1,15 @@
 from __future__ import annotations
 
+import asyncio
 import time
 import traceback
 from collections import Counter
 from typing import List, Sequence, Optional, Literal, Union, Iterator, Dict, Any, Callable, Set, cast
 
+from typing_extensions import TypedDict
 from pylabrobot.liquid_handling import LiquidHandler, LiquidHandlerBackend, LiquidHandlerChatterboxBackend, Strictness
+from unilabos.devices.liquid_handling.rviz_backend import UniLiquidHandlerRvizBackend
+from unilabos.devices.liquid_handling.laiyu.backend.laiyu_v_backend import UniLiquidHandlerLaiyuBackend
 from pylabrobot.liquid_handling.liquid_handler import TipPresenceProbingMethod
 from pylabrobot.liquid_handling.standard import GripDirection
 from pylabrobot.resources import (
@@ -23,38 +27,26 @@ from pylabrobot.resources import (
     Trash,
     Tip,
 )
-from typing_extensions import TypedDict
 
-from unilabos.devices.liquid_handling.rviz_backend import UniLiquidHandlerRvizBackend
 from unilabos.registry.placeholder_type import ResourceSlot
-from unilabos.resources.resource_tracker import (
+from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
-    ResourceTreeSet,
+from unilabos.resources.resource_tracker import ResourceTreeSet
-    ResourceDict,
-    EXTRA_SAMPLE_UUID,
-    EXTRA_UNILABOS_SAMPLE_UUID,
-)
-from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode, ROS2DeviceNode
 
 
 class SimpleReturn(TypedDict):
-    samples: List[List[ResourceDict]]
+    samples: list
-    volumes: List[float]
+    volumes: list
 
 
 class SetLiquidReturn(TypedDict):
-    wells: List[List[ResourceDict]]
+    wells: list
-    volumes: List[float]
+    volumes: list
 
 
 class SetLiquidFromPlateReturn(TypedDict):
-    plate: List[List[ResourceDict]]
+    plate: list
-    wells: List[List[ResourceDict]]
+    wells: list
-    volumes: List[float]
+    volumes: list
-
-
-class TransferLiquidReturn(TypedDict):
-    sources: List[List[ResourceDict]]
-    targets: List[List[ResourceDict]]
 
 
 class LiquidHandlerMiddleware(LiquidHandler):
@@ -236,11 +228,12 @@ class LiquidHandlerMiddleware(LiquidHandler):
         res_samples = []
         res_volumes = []
         for resource, volume, channel in zip(resources, vols, use_channels):
-            sample_uuid_value = resource.unilabos_extra.get(EXTRA_SAMPLE_UUID, None)
+            res_samples.append(
-            res_samples.append({"name": resource.name, EXTRA_SAMPLE_UUID: sample_uuid_value})
+                {"name": resource.name, "sample_uuid": resource.unilabos_extra.get("sample_uuid", None)}
+            )
             res_volumes.append(volume)
             self.pending_liquids_dict[channel] = {
-                EXTRA_SAMPLE_UUID: sample_uuid_value,
+                "sample_uuid": resource.unilabos_extra.get("sample_uuid", None),
                 "volume": volume,
             }
         return SimpleReturn(samples=res_samples, volumes=res_volumes)
@@ -282,10 +275,10 @@ class LiquidHandlerMiddleware(LiquidHandler):
         res_samples = []
         res_volumes = []
         for resource, volume, channel in zip(resources, vols, use_channels):
-            res_uuid = self.pending_liquids_dict[channel][EXTRA_SAMPLE_UUID]
+            res_uuid = self.pending_liquids_dict[channel]["sample_uuid"]
             self.pending_liquids_dict[channel]["volume"] -= volume
-            resource.unilabos_extra[EXTRA_SAMPLE_UUID] = res_uuid
+            resource.unilabos_extra["sample_uuid"] = res_uuid
-            res_samples.append({"name": resource.name, EXTRA_SAMPLE_UUID: res_uuid})
+            res_samples.append({"name": resource.name, "sample_uuid": res_uuid})
             res_volumes.append(volume)
 
         return SimpleReturn(samples=res_samples, volumes=res_volumes)
@@ -689,15 +682,14 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
             wells=ResourceTreeSet.from_plr_resources(wells, known_newly_created=False).dump(), volumes=res_volumes  # type: ignore
         )
 
+    @classmethod
     def set_liquid_from_plate(
-        self, plate: ResourceSlot, well_names: list[str], liquid_names: list[str], volumes: list[float]
+        cls, plate: ResourceSlot, well_names: list[str], liquid_names: list[str], volumes: list[float]
     ) -> SetLiquidFromPlateReturn:
         """Set the liquid in wells of a plate by well names (e.g., A1, A2, B3).
 
         如果 liquid_names 和 volumes 为空，但 plate 和 well_names 不为空，直接返回 plate 和 wells。
         """
-        assert issubclass(plate.__class__, Plate), "plate must be a Plate"
-        plate: Plate = cast(Plate, cast(Resource, plate))
         # 根据 well_names 获取对应的 Well 对象
         wells = [plate.get_well(name) for name in well_names]
         res_volumes = []
@@ -714,14 +706,6 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
             well.set_liquids([(liquid_name, volume)])  # type: ignore
             res_volumes.append(volume)
 
-        task = ROS2DeviceNode.run_async_func(self._ros_node.update_resource, True, **{"resources": wells})
-        submit_time = time.time()
-        while not task.done():
-            if time.time() - submit_time > 10:
-                self._ros_node.lab_logger().info(f"set_liquid_from_plate {plate} 超时")
-                break
-            time.sleep(0.01)
-
         return SetLiquidFromPlateReturn(
             plate=ResourceTreeSet.from_plr_resources([plate], known_newly_created=False).dump(),  # type: ignore
             wells=ResourceTreeSet.from_plr_resources(wells, known_newly_created=False).dump(),  # type: ignore
@@ -1127,7 +1111,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
         mix_liquid_height: Optional[float] = None,
         delays: Optional[List[int]] = None,
         none_keys: List[str] = [],
-    ) -> TransferLiquidReturn:
+    ):
         """Transfer liquid with automatic mode detection.
 
         Supports three transfer modes:
@@ -1267,11 +1251,6 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                 "Supported modes: 1->N, N->1, or N->N."
             )
 
-        return TransferLiquidReturn(
-            sources=ResourceTreeSet.from_plr_resources(list(sources), known_newly_created=False).dump(),  # type: ignore
-            targets=ResourceTreeSet.from_plr_resources(list(targets), known_newly_created=False).dump(),  # type: ignore
-        )
-
     async def _transfer_one_to_one(
         self,
         sources: Sequence[Container],

unilabos/devices/liquid_handling/prcxi/prcxi.py

@@ -52,7 +52,6 @@ from unilabos.devices.liquid_handling.liquid_handler_abstract import (
     SimpleReturn,
     SetLiquidReturn,
     SetLiquidFromPlateReturn,
-    TransferLiquidReturn,
 )
 from unilabos.registry.placeholder_type import ResourceSlot
 from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
@@ -155,29 +154,25 @@ class PRCXI9300Plate(Plate):
         **kwargs,
     ):
         # 如果 ordered_items 不为 None，直接使用
-        items = None
-        ordering_param = None
         if ordered_items is not None:
             items = ordered_items
         elif ordering is not None:
             # 检查 ordering 中的值是否是字符串（从 JSON 反序列化时的情况）
             # 如果是字符串，说明这是位置名称，需要让 Plate 自己创建 Well 对象
             # 我们只传递位置信息（键），不传递值，使用 ordering 参数
-            if ordering:
+            if ordering and isinstance(next(iter(ordering.values()), None), str):
-                values = list(ordering.values())
+                # ordering 的值是字符串，只使用键（位置信息）创建新的 OrderedDict
-                value = values[0]
+                # 传递 ordering 参数而不是 ordered_items，让 Plate 自己创建 Well 对象
-                if isinstance(value, str):
+                items = None
-                    # ordering 的值是字符串，只使用键（位置信息）创建新的 OrderedDict
+                # 使用 ordering 参数，只包含位置信息（键）
-                    # 传递 ordering 参数而不是 ordered_items，让 Plate 自己创建 Well 对象
+                ordering_param = collections.OrderedDict((k, None) for k in ordering.keys())
-                    items = None
-                    # 使用 ordering 参数，只包含位置信息（键）
-                    ordering_param = collections.OrderedDict((k, None) for k in ordering.keys())
-                elif value is None:
-                    ordering_param = ordering
             else:
                 # ordering 的值已经是对象，可以直接使用
                 items = ordering
                 ordering_param = None
+        else:
+            items = None
+            ordering_param = None
 
         # 根据情况传递不同的参数
         if items is not None:
@@ -718,7 +713,7 @@ class PRCXI9300Handler(LiquidHandlerAbstract):
         mix_liquid_height: Optional[float] = None,
         delays: Optional[List[int]] = None,
         none_keys: List[str] = [],
-    ) -> TransferLiquidReturn:
+    ):
         return await super().transfer_liquid(
             sources,
             targets,

unilabos/devices/virtual/virtual_transferpump.py

@@ -15,35 +15,35 @@ class VirtualPumpMode(Enum):
 
 class VirtualTransferPump:
     """虚拟转移泵类 - 模拟泵的基本功能，无需实际硬件 🚰"""
-
+    
     _ros_node: BaseROS2DeviceNode
-
+    
     def __init__(self, device_id: str = None, config: dict = None, **kwargs):
         """
         初始化虚拟转移泵
-
+        
         Args:
             device_id: 设备ID
             config: 配置字典，包含max_volume, port等参数
             **kwargs: 其他参数，确保兼容性
         """
         self.device_id = device_id or "virtual_transfer_pump"
-
+        
         # 从config或kwargs中获取参数，确保类型正确
         if config:
-            self.max_volume = float(config.get("max_volume", 25.0))
+            self.max_volume = float(config.get('max_volume', 25.0))
-            self.port = config.get("port", "VIRTUAL")
+            self.port = config.get('port', 'VIRTUAL')
         else:
-            self.max_volume = float(kwargs.get("max_volume", 25.0))
+            self.max_volume = float(kwargs.get('max_volume', 25.0))
-            self.port = kwargs.get("port", "VIRTUAL")
+            self.port = kwargs.get('port', 'VIRTUAL')
-
+        
-        self._transfer_rate = float(kwargs.get("transfer_rate", 0))
+        self._transfer_rate = float(kwargs.get('transfer_rate', 0))
-        self.mode = kwargs.get("mode", VirtualPumpMode.Normal)
+        self.mode = kwargs.get('mode', VirtualPumpMode.Normal)
-
+        
         # 状态变量 - 确保都是正确类型
         self._status = "Idle"
         self._position = 0.0  # float
-        self._max_velocity = 5.0  # float
+        self._max_velocity = 5.0  # float 
         self._current_volume = 0.0  # float
 
         # 🚀 新增：快速模式设置 - 大幅缩短执行时间
@@ -52,16 +52,14 @@ class VirtualTransferPump:
         self._fast_dispense_time = 1.0  # 快速喷射时间（秒）
 
         self.logger = logging.getLogger(f"VirtualTransferPump.{self.device_id}")
-
+        
         print(f"🚰 === 虚拟转移泵 {self.device_id} 已创建 === ✨")
-        print(
+        print(f"💨 快速模式: {'启用' if self._fast_mode else '禁用'} | 移动时间: {self._fast_move_time}s | 喷射时间: {self._fast_dispense_time}s")
-            f"💨 快速模式: {'启用' if self._fast_mode else '禁用'} | 移动时间: {self._fast_move_time}s | 喷射时间: {self._fast_dispense_time}s"
-        )
         print(f"📊 最大容量: {self.max_volume}mL | 端口: {self.port}")
-
+    
     def post_init(self, ros_node: BaseROS2DeviceNode):
         self._ros_node = ros_node
-
+    
     async def initialize(self) -> bool:
         """初始化虚拟泵 🚀"""
         self.logger.info(f"🔧 初始化虚拟转移泵 {self.device_id} ✨")
@@ -70,33 +68,33 @@ class VirtualTransferPump:
         self._current_volume = 0.0
         self.logger.info(f"✅ 转移泵 {self.device_id} 初始化完成 🚰")
         return True
-
+    
     async def cleanup(self) -> bool:
         """清理虚拟泵 🧹"""
         self.logger.info(f"🧹 清理虚拟转移泵 {self.device_id} 🔚")
         self._status = "Idle"
         self.logger.info(f"✅ 转移泵 {self.device_id} 清理完成 💤")
         return True
-
+    
     # 基本属性
     @property
     def status(self) -> str:
         return self._status
-
+    
     @property
     def position(self) -> float:
         """当前柱塞位置 (ml) 📍"""
         return self._position
-
+    
     @property
     def current_volume(self) -> float:
         """当前注射器中的体积 (ml) 💧"""
         return self._current_volume
-
+    
     @property
     def max_velocity(self) -> float:
         return self._max_velocity
-
+    
     @property
     def transfer_rate(self) -> float:
         return self._transfer_rate
@@ -105,17 +103,17 @@ class VirtualTransferPump:
         """设置最大速度 (ml/s) 🌊"""
         self._max_velocity = max(0.1, min(50.0, velocity))  # 限制在合理范围内
         self.logger.info(f"🌊 设置最大速度为 {self._max_velocity} mL/s")
-
+    
     def get_status(self) -> str:
         """获取泵状态 📋"""
         return self._status
-
+    
     async def _simulate_operation(self, duration: float):
         """模拟操作延时 ⏱️"""
         self._status = "Busy"
         await self._ros_node.sleep(duration)
         self._status = "Idle"
-
+    
     def _calculate_duration(self, volume: float, velocity: float = None) -> float:
         """
         计算操作持续时间 ⏰
@@ -123,10 +121,10 @@ class VirtualTransferPump:
         """
         if velocity is None:
             velocity = self._max_velocity
-
+        
         # 📊 计算理论时间（用于日志显示）
         theoretical_duration = abs(volume) / velocity
-
+        
         # 🚀 如果启用快速模式，使用固定的快速时间
         if self._fast_mode:
             # 根据操作类型选择快速时间
@@ -134,13 +132,13 @@ class VirtualTransferPump:
                 actual_duration = self._fast_move_time
             else:  # 很小的操作
                 actual_duration = 0.5
-
+            
             self.logger.debug(f"⚡ 快速模式: 理论时间 {theoretical_duration:.2f}s → 实际时间 {actual_duration:.2f}s")
             return actual_duration
         else:
             # 正常模式使用理论时间
             return theoretical_duration
-
+    
     def _calculate_display_duration(self, volume: float, velocity: float = None) -> float:
         """
         计算显示用的持续时间（用于日志） 📊
@@ -149,16 +147,16 @@ class VirtualTransferPump:
         if velocity is None:
             velocity = self._max_velocity
         return abs(volume) / velocity
-
+    
     # 新的set_position方法 - 专门用于SetPumpPosition动作
     async def set_position(self, position: float, max_velocity: float = None):
         """
         移动到绝对位置 - 专门用于SetPumpPosition动作 🎯
-
+        
         Args:
             position (float): 目标位置 (ml)
             max_velocity (float): 移动速度 (ml/s)
-
+        
         Returns:
             dict: 符合SetPumpPosition.action定义的结果
         """
@@ -166,19 +164,19 @@ class VirtualTransferPump:
             # 验证并转换参数
             target_position = float(position)
             velocity = float(max_velocity) if max_velocity is not None else self._max_velocity
-
+            
             # 限制位置在有效范围内
             target_position = max(0.0, min(float(self.max_volume), target_position))
-
+            
             # 计算移动距离
             volume_to_move = abs(target_position - self._position)
-
+            
             # 📊 计算显示用的时间（用于日志）
             display_duration = self._calculate_display_duration(volume_to_move, velocity)
-
+            
             # ⚡ 计算实际执行时间（快速模式）
             actual_duration = self._calculate_duration(volume_to_move, velocity)
-
+            
             # 🎯 确定操作类型和emoji
             if target_position > self._position:
                 operation_type = "吸液"
@@ -189,34 +187,28 @@ class VirtualTransferPump:
             else:
                 operation_type = "保持"
                 operation_emoji = "📍"
-
+            
             self.logger.info(f"🎯 SET_POSITION: {operation_type} {operation_emoji}")
-            self.logger.info(
+            self.logger.info(f"  📍 位置: {self._position:.2f}mL → {target_position:.2f}mL (移动 {volume_to_move:.2f}mL)")
-                f"  📍 位置: {self._position:.2f}mL → {target_position:.2f}mL (移动 {volume_to_move:.2f}mL)"
-            )
             self.logger.info(f"  🌊 速度: {velocity:.2f} mL/s")
             self.logger.info(f"  ⏰ 预计时间: {display_duration:.2f}s")
-
+            
             if self._fast_mode:
                 self.logger.info(f"  ⚡ 快速模式: 实际用时 {actual_duration:.2f}s")
-
+            
             # 🚀 模拟移动过程
             if volume_to_move > 0.01:  # 只有当移动距离足够大时才显示进度
                 start_position = self._position
                 steps = 5 if actual_duration > 0.5 else 2  # 根据实际时间调整步数
                 step_duration = actual_duration / steps
-
+                
                 self.logger.info(f"🚀 开始{operation_type}... {operation_emoji}")
-
+                
                 for i in range(steps + 1):
                     # 计算当前位置和进度
                     progress = (i / steps) * 100 if steps > 0 else 100
-                    current_pos = (
+                    current_pos = start_position + (target_position - start_position) * (i / steps) if steps > 0 else target_position
-                        start_position + (target_position - start_position) * (i / steps)
+                    
-                        if steps > 0
-                        else target_position
-                    )
-
                     # 更新状态
                     if i < steps:
                         self._status = f"{operation_type}中"
@@ -224,10 +216,10 @@ class VirtualTransferPump:
                     else:
                         self._status = "Idle"
                         status_emoji = "✅"
-
+                    
                     self._position = current_pos
                     self._current_volume = current_pos
-
+                    
                     # 显示进度（每25%或最后一步）
                     if i == 0:
                         self.logger.debug(f"  🔄 {operation_type}开始: {progress:.0f}%")
@@ -235,7 +227,7 @@ class VirtualTransferPump:
                         self.logger.debug(f"  🔄 {operation_type}进度: {progress:.0f}%")
                     elif i == steps:
                         self.logger.info(f"  ✅ {operation_type}完成: {progress:.0f}% | 当前位置: {current_pos:.2f}mL")
-
+                    
                     # 等待一小步时间
                     if i < steps and step_duration > 0:
                         await self._ros_node.sleep(step_duration)
@@ -244,27 +236,25 @@ class VirtualTransferPump:
                 self._position = target_position
                 self._current_volume = target_position
                 self.logger.info(f"  📍 微调完成: {target_position:.2f}mL")
-
+        
             # 确保最终位置准确
             self._position = target_position
             self._current_volume = target_position
             self._status = "Idle"
-
+            
             # 📊 最终状态日志
             if volume_to_move > 0.01:
-                self.logger.info(
+                self.logger.info(f"🎉 SET_POSITION 完成! 📍 最终位置: {self._position:.2f}mL | 💧 当前体积: {self._current_volume:.2f}mL")
-                    f"🎉 SET_POSITION 完成! 📍 最终位置: {self._position:.2f}mL | 💧 当前体积: {self._current_volume:.2f}mL"
+            
-                )
-
             # 返回符合action定义的结果
             return {
                 "success": True,
                 "message": f"✅ 成功移动到位置 {self._position:.2f}mL ({operation_type})",
                 "final_position": self._position,
                 "final_volume": self._current_volume,
-                "operation_type": operation_type,
+                "operation_type": operation_type
             }
-
+            
         except Exception as e:
             error_msg = f"❌ 设置位置失败: {str(e)}"
             self.logger.error(error_msg)
@@ -272,136 +262,134 @@ class VirtualTransferPump:
                 "success": False,
                 "message": error_msg,
                 "final_position": self._position,
-                "final_volume": self._current_volume,
+                "final_volume": self._current_volume
             }
-
+    
     # 其他泵操作方法
     async def pull_plunger(self, volume: float, velocity: float = None):
         """
         拉取柱塞（吸液） 📥
-
+        
         Args:
             volume (float): 要拉取的体积 (ml)
             velocity (float): 拉取速度 (ml/s)
         """
         new_position = min(self.max_volume, self._position + volume)
         actual_volume = new_position - self._position
-
+        
         if actual_volume <= 0:
             self.logger.warning("⚠️ 无法吸液 - 已达到最大容量")
             return
-
+        
         display_duration = self._calculate_display_duration(actual_volume, velocity)
         actual_duration = self._calculate_duration(actual_volume, velocity)
-
+        
         self.logger.info(f"📥 开始吸液: {actual_volume:.2f}mL")
         self.logger.info(f"  📍 位置: {self._position:.2f}mL → {new_position:.2f}mL")
         self.logger.info(f"  ⏰ 预计时间: {display_duration:.2f}s")
-
+        
         if self._fast_mode:
             self.logger.info(f"  ⚡ 快速模式: 实际用时 {actual_duration:.2f}s")
-
+        
         await self._simulate_operation(actual_duration)
-
+        
         self._position = new_position
         self._current_volume = new_position
-
+        
         self.logger.info(f"✅ 吸液完成: {actual_volume:.2f}mL | 💧 当前体积: {self._current_volume:.2f}mL")
 
     async def push_plunger(self, volume: float, velocity: float = None):
         """
         推出柱塞（排液） 📤
-
+        
         Args:
             volume (float): 要推出的体积 (ml)
             velocity (float): 推出速度 (ml/s)
         """
         new_position = max(0, self._position - volume)
         actual_volume = self._position - new_position
-
+        
         if actual_volume <= 0:
             self.logger.warning("⚠️ 无法排液 - 已达到最小容量")
             return
-
+        
         display_duration = self._calculate_display_duration(actual_volume, velocity)
         actual_duration = self._calculate_duration(actual_volume, velocity)
-
+        
         self.logger.info(f"📤 开始排液: {actual_volume:.2f}mL")
         self.logger.info(f"  📍 位置: {self._position:.2f}mL → {new_position:.2f}mL")
         self.logger.info(f"  ⏰ 预计时间: {display_duration:.2f}s")
-
+        
         if self._fast_mode:
             self.logger.info(f"  ⚡ 快速模式: 实际用时 {actual_duration:.2f}s")
-
+        
         await self._simulate_operation(actual_duration)
-
+        
         self._position = new_position
         self._current_volume = new_position
-
+        
         self.logger.info(f"✅ 排液完成: {actual_volume:.2f}mL | 💧 当前体积: {self._current_volume:.2f}mL")
 
     # 便捷操作方法
     async def aspirate(self, volume: float, velocity: float = None):
         """吸液操作 📥"""
         await self.pull_plunger(volume, velocity)
-
+    
     async def dispense(self, volume: float, velocity: float = None):
         """排液操作 📤"""
         await self.push_plunger(volume, velocity)
-
+    
     async def transfer(self, volume: float, aspirate_velocity: float = None, dispense_velocity: float = None):
         """转移操作（先吸后排） 🔄"""
         self.logger.info(f"🔄 开始转移操作: {volume:.2f}mL")
-
+        
         # 吸液
         await self.aspirate(volume, aspirate_velocity)
-
+        
         # 短暂停顿
         self.logger.debug("⏸️ 短暂停顿...")
         await self._ros_node.sleep(0.1)
-
+        
         # 排液
         await self.dispense(volume, dispense_velocity)
-
+    
     async def empty_syringe(self, velocity: float = None):
         """清空注射器"""
         await self.set_position(0, velocity)
-
+    
     async def fill_syringe(self, velocity: float = None):
         """充满注射器"""
         await self.set_position(self.max_volume, velocity)
-
+    
     async def stop_operation(self):
         """停止当前操作"""
         self._status = "Idle"
         self.logger.info("Operation stopped")
-
+    
     # 状态查询方法
     def get_position(self) -> float:
         """获取当前位置"""
         return self._position
-
+    
     def get_current_volume(self) -> float:
         """获取当前体积"""
         return self._current_volume
-
+    
     def get_remaining_capacity(self) -> float:
         """获取剩余容量"""
         return self.max_volume - self._current_volume
-
+    
     def is_empty(self) -> bool:
         """检查是否为空"""
         return self._current_volume <= 0.01  # 允许小量误差
-
+    
     def is_full(self) -> bool:
         """检查是否已满"""
         return self._current_volume >= (self.max_volume - 0.01)  # 允许小量误差
-
+    
     def __str__(self):
-        return (
+        return f"VirtualTransferPump({self.device_id}: {self._current_volume:.2f}/{self.max_volume} ml, {self._status})"
-            f"VirtualTransferPump({self.device_id}: {self._current_volume:.2f}/{self.max_volume} ml, {self._status})"
+    
-        )
-
     def __repr__(self):
         return self.__str__()
 
@@ -410,20 +398,20 @@ class VirtualTransferPump:
 async def demo():
     """虚拟泵使用示例"""
     pump = VirtualTransferPump("demo_pump", {"max_volume": 50.0})
-
+    
     await pump.initialize()
-
+    
     print(f"Initial state: {pump}")
-
+    
     # 测试set_position方法
     result = await pump.set_position(10.0, max_velocity=2.0)
     print(f"Set position result: {result}")
     print(f"After setting position to 10ml: {pump}")
-
+    
     # 吸液测试
     await pump.aspirate(5.0, velocity=2.0)
     print(f"After aspirating 5ml: {pump}")
-
+    
     # 清空测试
     result = await pump.set_position(0.0)
     print(f"Empty result: {result}")

unilabos/devices/virtual/workbench.py

@@ -11,10 +11,9 @@ Virtual Workbench Device - 模拟工作台设备
 
 注意：调用来自线程池，使用 threading.Lock 进行同步
 """
-
 import logging
 import time
-from typing import Dict, Any, Optional, List
+from typing import Dict, Any, Optional
 from dataclasses import dataclass
 from enum import Enum
 from threading import Lock, RLock
@@ -23,46 +22,37 @@ from typing_extensions import TypedDict
 
 from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
 from unilabos.utils.decorator import not_action
-from unilabos.resources.resource_tracker import SampleUUIDsType, LabSample, RETURN_UNILABOS_SAMPLES
 
 
 # ============ TypedDict 返回类型定义 ============
 
-
 class MoveToHeatingStationResult(TypedDict):
     """move_to_heating_station 返回类型"""
-
     success: bool
     station_id: int
     material_id: str
     material_number: int
     message: str
-    unilabos_samples: List[LabSample]
 
 
 class StartHeatingResult(TypedDict):
     """start_heating 返回类型"""
-
     success: bool
     station_id: int
     material_id: str
     material_number: int
     message: str
-    unilabos_samples: List[LabSample]
 
 
 class MoveToOutputResult(TypedDict):
     """move_to_output 返回类型"""
-
     success: bool
     station_id: int
     material_id: str
-    unilabos_samples: List[LabSample]
 
 
 class PrepareMaterialsResult(TypedDict):
     """prepare_materials 返回类型 - 批量准备物料"""
-
     success: bool
     count: int
     material_1: int  # 物料编号1
@@ -71,15 +61,12 @@ class PrepareMaterialsResult(TypedDict):
     material_4: int  # 物料编号4
     material_5: int  # 物料编号5
     message: str
-    unilabos_samples: List[LabSample]
 
 
 # ============ 状态枚举 ============
 
-
 class HeatingStationState(Enum):
     """加热台状态枚举"""
-
     IDLE = "idle"  # 空闲
     OCCUPIED = "occupied"  # 已放置物料，等待加热
     HEATING = "heating"  # 加热中
@@ -88,7 +75,6 @@ class HeatingStationState(Enum):
 
 class ArmState(Enum):
     """机械臂状态枚举"""
-
     IDLE = "idle"  # 空闲
     BUSY = "busy"  # 工作中
 
@@ -96,7 +82,6 @@ class ArmState(Enum):
 @dataclass
 class HeatingStation:
     """加热台数据结构"""
-
     station_id: int
     state: HeatingStationState = HeatingStationState.IDLE
     current_material: Optional[str] = None  # 当前物料 (如 "A1", "A2")
@@ -152,7 +137,8 @@ class VirtualWorkbench:
 
         # 加热台状态 (station_id -> HeatingStation) - 立即初始化，不依赖initialize()
         self._heating_stations: Dict[int, HeatingStation] = {
-            i: HeatingStation(station_id=i) for i in range(1, self.NUM_HEATING_STATIONS + 1)
+            i: HeatingStation(station_id=i)
+            for i in range(1, self.NUM_HEATING_STATIONS + 1)
         }
         self._stations_lock = RLock()  # 可重入锁，保护加热台状态
 
@@ -192,16 +178,14 @@ class VirtualWorkbench:
                 station.heating_progress = 0.0
 
         # 初始化状态
-        self.data.update(
+        self.data.update({
-            {
+            "status": "Ready",
-                "status": "Ready",
+            "arm_state": ArmState.IDLE.value,
-                "arm_state": ArmState.IDLE.value,
+            "arm_current_task": None,
-                "arm_current_task": None,
+            "heating_stations": self._get_stations_status(),
-                "heating_stations": self._get_stations_status(),
+            "active_tasks_count": 0,
-                "active_tasks_count": 0,
+            "message": "工作台就绪",
-                "message": "工作台就绪",
+        })
-            }
-        )
 
         self.logger.info(f"工作台初始化完成: {self.NUM_HEATING_STATIONS}个加热台就绪")
         return True
@@ -220,14 +204,12 @@ class VirtualWorkbench:
         with self._tasks_lock:
             self._active_tasks.clear()
 
-        self.data.update(
+        self.data.update({
-            {
+            "status": "Offline",
-                "status": "Offline",
+            "arm_state": ArmState.IDLE.value,
-                "arm_state": ArmState.IDLE.value,
+            "heating_stations": {},
-                "heating_stations": {},
+            "message": "工作台已关闭",
-                "message": "工作台已关闭",
+        })
-            }
-        )
         return True
 
     def _get_stations_status(self) -> Dict[int, Dict[str, Any]]:
@@ -245,14 +227,12 @@ class VirtualWorkbench:
 
     def _update_data_status(self, message: Optional[str] = None):
         """更新状态数据"""
-        self.data.update(
+        self.data.update({
-            {
+            "arm_state": self._arm_state.value,
-                "arm_state": self._arm_state.value,
+            "arm_current_task": self._arm_current_task,
-                "arm_current_task": self._arm_current_task,
+            "heating_stations": self._get_stations_status(),
-                "heating_stations": self._get_stations_status(),
+            "active_tasks_count": len(self._active_tasks),
-                "active_tasks_count": len(self._active_tasks),
+        })
-            }
-        )
         if message:
             self.data["message"] = message
 
@@ -300,7 +280,6 @@ class VirtualWorkbench:
 
     def prepare_materials(
         self,
-        sample_uuids: SampleUUIDsType,
         count: int = 5,
     ) -> PrepareMaterialsResult:
         """
@@ -318,7 +297,10 @@ class VirtualWorkbench:
         # 生成物料列表 A1 - A{count}
         materials = [i for i in range(1, count + 1)]
 
-        self.logger.info(f"[准备物料] 生成 {count} 个物料: " f"A1-A{count} -> material_1~material_{count}")
+        self.logger.info(
+            f"[准备物料] 生成 {count} 个物料: "
+            f"A1-A{count} -> material_1~material_{count}"
+        )
 
         return {
             "success": True,
@@ -329,12 +311,10 @@ class VirtualWorkbench:
             "material_4": materials[3] if len(materials) > 3 else 0,
             "material_5": materials[4] if len(materials) > 4 else 0,
             "message": f"已准备 {count} 个物料: A1-A{count}",
-            "unilabos_samples": [LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for sample_uuid, content in sample_uuids.items()]
         }
 
     def move_to_heating_station(
         self,
-        sample_uuids: SampleUUIDsType,
         material_number: int,
     ) -> MoveToHeatingStationResult:
         """
@@ -411,9 +391,6 @@ class VirtualWorkbench:
                 "material_id": material_id,
                 "material_number": material_number,
                 "message": f"{material_id}已成功移动到加热台{station_id}",
-                "unilabos_samples": [
-                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                    sample_uuid, content in sample_uuids.items()]
             }
 
         except Exception as e:
@@ -426,14 +403,10 @@ class VirtualWorkbench:
                 "material_id": material_id,
                 "material_number": material_number,
                 "message": f"移动失败: {str(e)}",
-                "unilabos_samples": [
-                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                    sample_uuid, content in sample_uuids.items()]
             }
 
     def start_heating(
         self,
-        sample_uuids: SampleUUIDsType,
         station_id: int,
         material_number: int,
     ) -> StartHeatingResult:
@@ -456,9 +429,6 @@ class VirtualWorkbench:
                 "material_id": "",
                 "material_number": material_number,
                 "message": f"无效的加热台ID: {station_id}",
-                "unilabos_samples": [
-                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                    sample_uuid, content in sample_uuids.items()]
             }
 
         with self._stations_lock:
@@ -471,9 +441,6 @@ class VirtualWorkbench:
                     "material_id": "",
                     "material_number": material_number,
                     "message": f"加热台{station_id}上没有物料",
-                    "unilabos_samples": [
-                        LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                        sample_uuid, content in sample_uuids.items()]
                 }
 
             if station.state == HeatingStationState.HEATING:
@@ -483,9 +450,6 @@ class VirtualWorkbench:
                     "material_id": station.current_material,
                     "material_number": material_number,
                     "message": f"加热台{station_id}已经在加热中",
-                    "unilabos_samples": [
-                        LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                        sample_uuid, content in sample_uuids.items()]
                 }
 
             material_id = station.current_material
@@ -535,14 +499,10 @@ class VirtualWorkbench:
             "material_id": material_id,
             "material_number": material_number,
             "message": f"加热台{station_id}加热完成",
-            "unilabos_samples": [
-                LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                sample_uuid, content in sample_uuids.items()]
         }
 
     def move_to_output(
         self,
-        sample_uuids: SampleUUIDsType,
         station_id: int,
         material_number: int,
     ) -> MoveToOutputResult:
@@ -565,9 +525,6 @@ class VirtualWorkbench:
                 "material_id": "",
                 "output_position": f"C{output_number}",
                 "message": f"无效的加热台ID: {station_id}",
-                "unilabos_samples": [
-                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                    sample_uuid, content in sample_uuids.items()]
             }
 
         with self._stations_lock:
@@ -581,9 +538,6 @@ class VirtualWorkbench:
                     "material_id": "",
                     "output_position": f"C{output_number}",
                     "message": f"加热台{station_id}上没有物料",
-                    "unilabos_samples": [
-                        LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                        sample_uuid, content in sample_uuids.items()]
                 }
 
             if station.state != HeatingStationState.COMPLETED:
@@ -593,9 +547,6 @@ class VirtualWorkbench:
                     "material_id": material_id,
                     "output_position": f"C{output_number}",
                     "message": f"加热台{station_id}尚未完成加热 (当前状态: {station.state.value})",
-                    "unilabos_samples": [
-                        LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                        sample_uuid, content in sample_uuids.items()]
                 }
 
         output_position = f"C{output_number}"
@@ -644,9 +595,6 @@ class VirtualWorkbench:
                 "material_id": material_id,
                 "output_position": output_position,
                 "message": f"{material_id}已成功移动到{output_position}",
-                "unilabos_samples": [
-                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                    sample_uuid, content in sample_uuids.items()]
             }
 
         except Exception as e:
@@ -659,9 +607,6 @@ class VirtualWorkbench:
                 "material_id": "",
                 "output_position": output_position,
                 "message": f"移动失败: {str(e)}",
-                "unilabos_samples": [
-                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                    sample_uuid, content in sample_uuids.items()]
             }
 
     # ============ 状态属性 ============

unilabos/registry/devices/liquid_handler.yaml

@@ -638,7 +638,7 @@ liquid_handler:
         placeholder_keys: {}
         result: {}
         schema:
-          description: 吸头迭代函数。用于自动管理和切换枪头盒中的吸头，实现批量实验中的吸头自动分配和追踪。该函数监控吸头使用状态，自动切换到下一个可用吸头位置，确保实验流程的连续性。适用于高通量实验、批量处理、自动化流水线等需要大量吸头管理的应用场景。
+          description: 吸头迭代函数。用于自动管理和切换吸头架中的吸头，实现批量实验中的吸头自动分配和追踪。该函数监控吸头使用状态，自动切换到下一个可用吸头位置，确保实验流程的连续性。适用于高通量实验、批量处理、自动化流水线等需要大量吸头管理的应用场景。
           properties:
             feedback: {}
             goal:
@@ -712,43 +712,6 @@ liquid_handler:
           title: set_group参数
           type: object
         type: UniLabJsonCommand
-      auto-set_liquid_from_plate:
-        feedback: {}
-        goal: {}
-        goal_default:
-          liquid_names: null
-          plate: null
-          volumes: null
-          well_names: null
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                liquid_names:
-                  type: string
-                plate:
-                  type: string
-                volumes:
-                  type: string
-                well_names:
-                  type: string
-              required:
-              - plate
-              - well_names
-              - liquid_names
-              - volumes
-              type: object
-            result: {}
-          required:
-          - goal
-          title: set_liquid_from_plate参数
-          type: object
-        type: UniLabJsonCommand
       auto-set_tiprack:
         feedback: {}
         goal: {}
@@ -758,7 +721,7 @@ liquid_handler:
         placeholder_keys: {}
         result: {}
         schema:
-          description: 枪头盒设置函数。用于配置和初始化液体处理系统的枪头盒信息，包括枪头盒位置、类型、容量等参数。该函数建立吸头资源管理系统，为后续的吸头选择和使用提供基础配置。适用于系统初始化、枪头盒更换、实验配置等需要吸头资源管理的操作场景。
+          description: 吸头架设置函数。用于配置和初始化液体处理系统的吸头架信息，包括吸头架位置、类型、容量等参数。该函数建立吸头资源管理系统，为后续的吸头选择和使用提供基础配置。适用于系统初始化、吸头架更换、实验配置等需要吸头资源管理的操作场景。
           properties:
             feedback: {}
             goal:
@@ -4130,32 +4093,32 @@ liquid_handler:
           - 0
         handles:
           input:
-          - data_key: sources
+          - data_key: liquid
             data_source: handle
             data_type: resource
             handler_key: sources
-            label: 待移动液体
+            label: sources
-          - data_key: targets
+          - data_key: liquid
-            data_source: handle
-            data_type: resource
-            handler_key: targets
-            label: 转移目标
-          - data_key: tip_racks
-            data_source: handle
-            data_type: resource
-            handler_key: tip_rack
-            label: 枪头盒
-          output:
-          - data_key: sources.@flatten
             data_source: executor
             data_type: resource
+            handler_key: targets
+            label: targets
+          - data_key: liquid
+            data_source: executor
+            data_type: resource
+            handler_key: tip_rack
+            label: tip_rack
+          output:
+          - data_key: liquid
+            data_source: handle
+            data_type: resource
             handler_key: sources_out
-            label: 移液后源孔
+            label: sources
-          - data_key: targets.@flatten
+          - data_key: liquid
             data_source: executor
             data_type: resource
             handler_key: targets_out
-            label: 移液后目标孔
+            label: targets
         placeholder_keys:
           sources: unilabos_resources
           targets: unilabos_resources
@@ -5151,34 +5114,19 @@ liquid_handler.biomek:
           - 0
         handles:
           input:
-          - data_key: sources
+          - data_key: liquid
             data_source: handle
             data_type: resource
-            handler_key: sources
+            handler_key: liquid-input
             io_type: target
-            label: 待移动液体
+            label: Liquid Input
-          - data_key: targets
-            data_source: handle
-            data_type: resource
-            handler_key: targets
-            label: 转移目标
-          - data_key: tip_racks
-            data_source: handle
-            data_type: resource
-            handler_key: tip_rack
-            label: 枪头盒
           output:
-          - data_key: sources.@flatten
+          - data_key: liquid
             data_source: executor
             data_type: resource
-            handler_key: sources_out
+            handler_key: liquid-output
             io_type: source
-            label: 移液后源孔
+            label: Liquid Output
-          - data_key: targets.@flatten
-            data_source: executor
-            data_type: resource
-            handler_key: targets_out
-            label: 移液后目标孔
         placeholder_keys:
           sources: unilabos_resources
           targets: unilabos_resources
@@ -9468,7 +9416,7 @@ liquid_handler.prcxi:
           well_names: null
         handles:
           input:
-          - data_key: '@this.0@@@plate'
+          - data_key: plate
             data_source: handle
             data_type: resource
             handler_key: input_plate
@@ -9590,195 +9538,9 @@ liquid_handler.prcxi:
               - volumes
               type: object
             result:
-              $defs:
-                ResourceDict:
-                  properties:
-                    class:
-                      description: Resource class name
-                      title: Class
-                      type: string
-                    config:
-                      additionalProperties: true
-                      description: Resource configuration
-                      title: Config
-                      type: object
-                    data:
-                      additionalProperties: true
-                      description: 'Resource data, eg: container liquid data'
-                      title: Data
-                      type: object
-                    description:
-                      default: ''
-                      description: Resource description
-                      title: Description
-                      type: string
-                    extra:
-                      additionalProperties: true
-                      description: 'Extra data, eg: slot index'
-                      title: Extra
-                      type: object
-                    icon:
-                      default: ''
-                      description: Resource icon
-                      title: Icon
-                      type: string
-                    id:
-                      description: Resource ID
-                      title: Id
-                      type: string
-                    model:
-                      additionalProperties: true
-                      description: Resource model
-                      title: Model
-                      type: object
-                    name:
-                      description: Resource name
-                      title: Name
-                      type: string
-                    parent:
-                      anyOf:
-                      - $ref: '#/$defs/ResourceDict'
-                      - type: 'null'
-                      default: null
-                      description: Parent resource object
-                    parent_uuid:
-                      anyOf:
-                      - type: string
-                      - type: 'null'
-                      default: null
-                      description: Parent resource uuid
-                      title: Parent Uuid
-                    pose:
-                      $ref: '#/$defs/ResourceDictPosition'
-                      description: Resource position
-                    schema:
-                      additionalProperties: true
-                      description: Resource schema
-                      title: Schema
-                      type: object
-                    type:
-                      anyOf:
-                      - const: device
-                        type: string
-                      - type: string
-                      description: Resource type
-                      title: Type
-                    uuid:
-                      description: Resource UUID
-                      title: Uuid
-                      type: string
-                  required:
-                  - id
-                  - uuid
-                  - name
-                  - type
-                  - class
-                  - config
-                  - data
-                  - extra
-                  title: ResourceDict
-                  type: object
-                ResourceDictPosition:
-                  properties:
-                    cross_section_type:
-                      default: rectangle
-                      description: Cross section type
-                      enum:
-                      - rectangle
-                      - circle
-                      - rounded_rectangle
-                      title: Cross Section Type
-                      type: string
-                    layout:
-                      default: x-y
-                      description: Resource layout
-                      enum:
-                      - 2d
-                      - x-y
-                      - z-y
-                      - x-z
-                      title: Layout
-                      type: string
-                    position:
-                      $ref: '#/$defs/ResourceDictPositionObject'
-                      description: Resource position
-                    position3d:
-                      $ref: '#/$defs/ResourceDictPositionObject'
-                      description: Resource position in 3D space
-                    rotation:
-                      $ref: '#/$defs/ResourceDictPositionObject'
-                      description: Resource rotation
-                    scale:
-                      $ref: '#/$defs/ResourceDictPositionScale'
-                      description: Resource scale
-                    size:
-                      $ref: '#/$defs/ResourceDictPositionSize'
-                      description: Resource size
-                  title: ResourceDictPosition
-                  type: object
-                ResourceDictPositionObject:
-                  properties:
-                    x:
-                      default: 0.0
-                      description: X coordinate
-                      title: X
-                      type: number
-                    y:
-                      default: 0.0
-                      description: Y coordinate
-                      title: Y
-                      type: number
-                    z:
-                      default: 0.0
-                      description: Z coordinate
-                      title: Z
-                      type: number
-                  title: ResourceDictPositionObject
-                  type: object
-                ResourceDictPositionScale:
-                  properties:
-                    x:
-                      default: 0.0
-                      description: x scale
-                      title: X
-                      type: number
-                    y:
-                      default: 0.0
-                      description: y scale
-                      title: Y
-                      type: number
-                    z:
-                      default: 0.0
-                      description: z scale
-                      title: Z
-                      type: number
-                  title: ResourceDictPositionScale
-                  type: object
-                ResourceDictPositionSize:
-                  properties:
-                    depth:
-                      default: 0.0
-                      description: Depth
-                      title: Depth
-                      type: number
-                    height:
-                      default: 0.0
-                      description: Height
-                      title: Height
-                      type: number
-                    width:
-                      default: 0.0
-                      description: Width
-                      title: Width
-                      type: number
-                  title: ResourceDictPositionSize
-                  type: object
               properties:
                 plate:
-                  items:
+                  items: {}
-                    items:
-                      $ref: '#/$defs/ResourceDict'
-                    type: array
                   title: Plate
                   type: array
                 volumes:
@@ -9787,10 +9549,7 @@ liquid_handler.prcxi:
                   title: Volumes
                   type: array
                 wells:
-                  items:
+                  items: {}
-                    items:
-                      $ref: '#/$defs/ResourceDict'
-                    type: array
                   title: Wells
                   type: array
               required:
@@ -10163,18 +9922,18 @@ liquid_handler.prcxi:
             data_source: handle
             data_type: resource
             handler_key: tip_rack_identifier
-            label: 枪头盒
+            label: 墙头盒
           output:
-          - data_key: sources.@flatten
+          - data_key: liquid
-            data_source: executor
+            data_source: handle
             data_type: resource
             handler_key: sources_out
-            label: 移液后源孔
+            label: sources
-          - data_key: targets.@flatten
+          - data_key: liquid
             data_source: executor
             data_type: resource
             handler_key: targets_out
-            label: 移液后目标孔
+            label: targets
         placeholder_keys:
           sources: unilabos_resources
           targets: unilabos_resources

unilabos/registry/devices/virtual_device.yaml

@@ -5835,25 +5835,6 @@ virtual_workbench:
               - material_number
               type: object
             result:
-              $defs:
-                LabSample:
-                  properties:
-                    extra:
-                      additionalProperties: true
-                      title: Extra
-                      type: object
-                    oss_path:
-                      title: Oss Path
-                      type: string
-                    sample_uuid:
-                      title: Sample Uuid
-                      type: string
-                  required:
-                  - sample_uuid
-                  - oss_path
-                  - extra
-                  title: LabSample
-                  type: object
               description: move_to_heating_station 返回类型
               properties:
                 material_id:
@@ -5872,18 +5853,12 @@ virtual_workbench:
                 success:
                   title: Success
                   type: boolean
-                unilabos_samples:
-                  items:
-                    $ref: '#/$defs/LabSample'
-                  title: Unilabos Samples
-                  type: array
               required:
               - success
               - station_id
               - material_id
               - material_number
               - message
-              - unilabos_samples
               title: MoveToHeatingStationResult
               type: object
           required:
@@ -5928,25 +5903,6 @@ virtual_workbench:
               - material_number
               type: object
             result:
-              $defs:
-                LabSample:
-                  properties:
-                    extra:
-                      additionalProperties: true
-                      title: Extra
-                      type: object
-                    oss_path:
-                      title: Oss Path
-                      type: string
-                    sample_uuid:
-                      title: Sample Uuid
-                      type: string
-                  required:
-                  - sample_uuid
-                  - oss_path
-                  - extra
-                  title: LabSample
-                  type: object
               description: move_to_output 返回类型
               properties:
                 material_id:
@@ -5958,16 +5914,10 @@ virtual_workbench:
                 success:
                   title: Success
                   type: boolean
-                unilabos_samples:
-                  items:
-                    $ref: '#/$defs/LabSample'
-                  title: Unilabos Samples
-                  type: array
               required:
               - success
               - station_id
               - material_id
-              - unilabos_samples
               title: MoveToOutputResult
               type: object
           required:
@@ -6022,25 +5972,6 @@ virtual_workbench:
               required: []
               type: object
             result:
-              $defs:
-                LabSample:
-                  properties:
-                    extra:
-                      additionalProperties: true
-                      title: Extra
-                      type: object
-                    oss_path:
-                      title: Oss Path
-                      type: string
-                    sample_uuid:
-                      title: Sample Uuid
-                      type: string
-                  required:
-                  - sample_uuid
-                  - oss_path
-                  - extra
-                  title: LabSample
-                  type: object
               description: prepare_materials 返回类型 - 批量准备物料
               properties:
                 count:
@@ -6067,11 +5998,6 @@ virtual_workbench:
                 success:
                   title: Success
                   type: boolean
-                unilabos_samples:
-                  items:
-                    $ref: '#/$defs/LabSample'
-                  title: Unilabos Samples
-                  type: array
               required:
               - success
               - count
@@ -6081,7 +6007,6 @@ virtual_workbench:
               - material_4
               - material_5
               - message
-              - unilabos_samples
               title: PrepareMaterialsResult
               type: object
           required:
@@ -6137,25 +6062,6 @@ virtual_workbench:
               - material_number
               type: object
             result:
-              $defs:
-                LabSample:
-                  properties:
-                    extra:
-                      additionalProperties: true
-                      title: Extra
-                      type: object
-                    oss_path:
-                      title: Oss Path
-                      type: string
-                    sample_uuid:
-                      title: Sample Uuid
-                      type: string
-                  required:
-                  - sample_uuid
-                  - oss_path
-                  - extra
-                  title: LabSample
-                  type: object
               description: start_heating 返回类型
               properties:
                 material_id:
@@ -6173,18 +6079,12 @@ virtual_workbench:
                 success:
                   title: Success
                   type: boolean
-                unilabos_samples:
-                  items:
-                    $ref: '#/$defs/LabSample'
-                  title: Unilabos Samples
-                  type: array
               required:
               - success
               - station_id
               - material_id
               - material_number
               - message
-              - unilabos_samples
               title: StartHeatingResult
               type: object
           required:

unilabos/registry/registry.py

@@ -4,8 +4,6 @@ import os
 import sys
 import inspect
 import importlib
-import threading
-from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 from typing import Any, Dict, List, Union, Tuple
 
@@ -62,7 +60,6 @@ class Registry:
         self.device_module_to_registry = {}
         self.resource_type_registry = {}
         self._setup_called = False  # 跟踪setup是否已调用
-        self._registry_lock = threading.Lock()  # 多线程加载时的锁
         # 其他状态变量
         # self.is_host_mode = False  # 移至BasicConfig中
 
@@ -180,7 +177,8 @@ class Registry:
                                 "result": {},
                                 "schema": test_latency_schema,
                                 "goal_default": {
-                                    arg["name"]: arg["default"] for arg in test_latency_method_info.get("args", [])
+                                    arg["name"]: arg["default"]
+                                    for arg in test_latency_method_info.get("args", [])
                                 },
                                 "handles": {},
                             },
@@ -264,115 +262,67 @@ class Registry:
         # 标记setup已被调用
         self._setup_called = True
 
-    def _load_single_resource_file(
-        self, file: Path, complete_registry: bool, upload_registry: bool
-    ) -> Tuple[Dict[str, Any], Dict[str, Any], bool]:
-        """
-        加载单个资源文件 (线程安全)
-
-        Returns:
-            (data, complete_data, is_valid): 资源数据, 完整数据, 是否有效
-        """
-        try:
-            with open(file, encoding="utf-8", mode="r") as f:
-                data = yaml.safe_load(io.StringIO(f.read()))
-        except Exception as e:
-            logger.warning(f"[UniLab Registry] 读取资源文件失败: {file}, 错误: {e}")
-            return {}, {}, False
-
-        if not data:
-            return {}, {}, False
-
-        complete_data = {}
-        for resource_id, resource_info in data.items():
-            if "version" not in resource_info:
-                resource_info["version"] = "1.0.0"
-            if "category" not in resource_info:
-                resource_info["category"] = [file.stem]
-            elif file.stem not in resource_info["category"]:
-                resource_info["category"].append(file.stem)
-            elif not isinstance(resource_info.get("category"), list):
-                resource_info["category"] = [resource_info["category"]]
-            if "config_info" not in resource_info:
-                resource_info["config_info"] = []
-            if "icon" not in resource_info:
-                resource_info["icon"] = ""
-            if "handles" not in resource_info:
-                resource_info["handles"] = []
-            if "init_param_schema" not in resource_info:
-                resource_info["init_param_schema"] = {}
-            if "config_info" in resource_info:
-                del resource_info["config_info"]
-            if "file_path" in resource_info:
-                del resource_info["file_path"]
-            complete_data[resource_id] = copy.deepcopy(dict(sorted(resource_info.items())))
-            if upload_registry:
-                class_info = resource_info.get("class", {})
-                if len(class_info) and "module" in class_info:
-                    if class_info.get("type") == "pylabrobot":
-                        res_class = get_class(class_info["module"])
-                        if callable(res_class) and not isinstance(res_class, type):
-                            res_instance = res_class(res_class.__name__)
-                            res_ulr = tree_to_list([resource_plr_to_ulab(res_instance)])
-                            resource_info["config_info"] = res_ulr
-            resource_info["registry_type"] = "resource"
-            resource_info["file_path"] = str(file.absolute()).replace("\\", "/")
-
-        complete_data = dict(sorted(complete_data.items()))
-        complete_data = copy.deepcopy(complete_data)
-
-        if complete_registry:
-            try:
-                with open(file, "w", encoding="utf-8") as f:
-                    yaml.dump(complete_data, f, allow_unicode=True, default_flow_style=False, Dumper=NoAliasDumper)
-            except Exception as e:
-                logger.warning(f"[UniLab Registry] 写入资源文件失败: {file}, 错误: {e}")
-
-        return data, complete_data, True
-
     def load_resource_types(self, path: os.PathLike, complete_registry: bool, upload_registry: bool):
         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)}")
-
-        if not files:
-            return
-
-        # 使用线程池并行加载
-        max_workers = min(8, len(files))
-        results = []
-
-        with ThreadPoolExecutor(max_workers=max_workers) as executor:
-            future_to_file = {
-                executor.submit(self._load_single_resource_file, file, complete_registry, upload_registry): file
-                for file in files
-            }
-            for future in as_completed(future_to_file):
-                file = future_to_file[future]
-                try:
-                    data, complete_data, is_valid = future.result()
-                    if is_valid:
-                        results.append((file, data))
-                except Exception as e:
-                    logger.warning(f"[UniLab Registry] 处理资源文件异常: {file}, 错误: {e}")
-
-        # 线程安全地更新注册表
         current_resource_number = len(self.resource_type_registry) + 1
-        with self._registry_lock:
+        for i, file in enumerate(files):
-            for i, (file, data) in enumerate(results):
+            with open(file, encoding="utf-8", mode="r") as f:
+                data = yaml.safe_load(io.StringIO(f.read()))
+            complete_data = {}
+            if data:
+                # 为每个资源添加文件路径信息
+                for resource_id, resource_info in data.items():
+                    if "version" not in resource_info:
+                        resource_info["version"] = "1.0.0"
+                    if "category" not in resource_info:
+                        resource_info["category"] = [file.stem]
+                    elif file.stem not in resource_info["category"]:
+                        resource_info["category"].append(file.stem)
+                    elif not isinstance(resource_info.get("category"), list):
+                        resource_info["category"] = [resource_info["category"]]
+                    if "config_info" not in resource_info:
+                        resource_info["config_info"] = []
+                    if "icon" not in resource_info:
+                        resource_info["icon"] = ""
+                    if "handles" not in resource_info:
+                        resource_info["handles"] = []
+                    if "init_param_schema" not in resource_info:
+                        resource_info["init_param_schema"] = {}
+                    if "config_info" in resource_info:
+                        del resource_info["config_info"]
+                    if "file_path" in resource_info:
+                        del resource_info["file_path"]
+                    complete_data[resource_id] = copy.deepcopy(dict(sorted(resource_info.items())))
+                    if upload_registry:
+                        class_info = resource_info.get("class", {})
+                        if len(class_info) and "module" in class_info:
+                            if class_info.get("type") == "pylabrobot":
+                                res_class = get_class(class_info["module"])
+                                if callable(res_class) and not isinstance(
+                                    res_class, type
+                                ):  # 有的是类，有的是函数，这里暂时只登记函数类的
+                                    res_instance = res_class(res_class.__name__)
+                                    res_ulr = tree_to_list([resource_plr_to_ulab(res_instance)])
+                                    resource_info["config_info"] = res_ulr
+                    resource_info["registry_type"] = "resource"
+                    resource_info["file_path"] = str(file.absolute()).replace("\\", "/")
+                complete_data = dict(sorted(complete_data.items()))
+                complete_data = copy.deepcopy(complete_data)
+                if complete_registry:
+                    with open(file, "w", encoding="utf-8") as f:
+                        yaml.dump(complete_data, f, allow_unicode=True, default_flow_style=False, Dumper=NoAliasDumper)
+
                 self.resource_type_registry.update(data)
-                logger.trace(
+                logger.trace(  # type: ignore
-                    f"[UniLab Registry] Resource-{current_resource_number} File-{i+1}/{len(results)} "
+                    f"[UniLab Registry] Resource-{current_resource_number} File-{i+1}/{len(files)} "
                     + f"Add {list(data.keys())}"
                 )
                 current_resource_number += 1
-
+            else:
-        # 记录无效文件
+                logger.debug(f"[UniLab Registry] Res File-{i+1}/{len(files)} Not Valid YAML File: {file.absolute()}")
-        valid_files = {r[0] for r in results}
-        for file in files:
-            if file not in valid_files:
-                logger.debug(f"[UniLab Registry] Res File Not Valid YAML File: {file.absolute()}")
 
     def _extract_class_docstrings(self, module_string: str) -> Dict[str, str]:
         """
@@ -724,244 +674,213 @@ class Registry:
                 "handles": {},
             }
 
-    def _load_single_device_file(
-        self, file: Path, complete_registry: bool, get_yaml_from_goal_type
-    ) -> Tuple[Dict[str, Any], Dict[str, Any], bool, List[str]]:
-        """
-        加载单个设备文件 (线程安全)
-
-        Returns:
-            (data, complete_data, is_valid, device_ids): 设备数据, 完整数据, 是否有效, 设备ID列表
-        """
-        try:
-            with open(file, encoding="utf-8", mode="r") as f:
-                data = yaml.safe_load(io.StringIO(f.read()))
-        except Exception as e:
-            logger.warning(f"[UniLab Registry] 读取设备文件失败: {file}, 错误: {e}")
-            return {}, {}, False, []
-
-        if not data:
-            return {}, {}, False, []
-
-        complete_data = {}
-        action_str_type_mapping = {
-            "UniLabJsonCommand": "UniLabJsonCommand",
-            "UniLabJsonCommandAsync": "UniLabJsonCommandAsync",
-        }
-        status_str_type_mapping = {}
-        device_ids = []
-
-        for device_id, device_config in data.items():
-            if "version" not in device_config:
-                device_config["version"] = "1.0.0"
-            if "category" not in device_config:
-                device_config["category"] = [file.stem]
-            elif file.stem not in device_config["category"]:
-                device_config["category"].append(file.stem)
-            if "config_info" not in device_config:
-                device_config["config_info"] = []
-            if "description" not in device_config:
-                device_config["description"] = ""
-            if "icon" not in device_config:
-                device_config["icon"] = ""
-            if "handles" not in device_config:
-                device_config["handles"] = []
-            if "init_param_schema" not in device_config:
-                device_config["init_param_schema"] = {}
-            if "class" in device_config:
-                if "status_types" not in device_config["class"] or device_config["class"]["status_types"] is None:
-                    device_config["class"]["status_types"] = {}
-                if (
-                    "action_value_mappings" not in device_config["class"]
-                    or device_config["class"]["action_value_mappings"] is None
-                ):
-                    device_config["class"]["action_value_mappings"] = {}
-                enhanced_info = {}
-                if complete_registry:
-                    device_config["class"]["status_types"].clear()
-                    enhanced_info = get_enhanced_class_info(device_config["class"]["module"], use_dynamic=True)
-                    if not enhanced_info.get("dynamic_import_success", False):
-                        continue
-                    device_config["class"]["status_types"].update(
-                        {k: v["return_type"] for k, v in enhanced_info["status_methods"].items()}
-                    )
-                for status_name, status_type in device_config["class"]["status_types"].items():
-                    if isinstance(status_type, tuple) or status_type in ["Any", "None", "Unknown"]:
-                        status_type = "String"
-                        device_config["class"]["status_types"][status_name] = status_type
-                    try:
-                        target_type = self._replace_type_with_class(status_type, device_id, f"状态 {status_name}")
-                    except ROSMsgNotFound:
-                        continue
-                    if target_type in [dict, list]:
-                        target_type = String
-                    status_str_type_mapping[status_type] = target_type
-                device_config["class"]["status_types"] = dict(sorted(device_config["class"]["status_types"].items()))
-                if complete_registry:
-                    old_action_configs = {}
-                    for action_name, action_config in device_config["class"]["action_value_mappings"].items():
-                        old_action_configs[action_name] = action_config
-
-                    device_config["class"]["action_value_mappings"] = {
-                        k: v
-                        for k, v in device_config["class"]["action_value_mappings"].items()
-                        if not k.startswith("auto-")
-                    }
-                    device_config["class"]["action_value_mappings"].update(
-                        {
-                            f"auto-{k}": {
-                                "type": "UniLabJsonCommandAsync" if v["is_async"] else "UniLabJsonCommand",
-                                "goal": {},
-                                "feedback": {},
-                                "result": {},
-                                "schema": self._generate_unilab_json_command_schema(
-                                    v["args"],
-                                    k,
-                                    v.get("return_annotation"),
-                                    old_action_configs.get(f"auto-{k}", {}).get("schema"),
-                                ),
-                                "goal_default": {i["name"]: i["default"] for i in v["args"]},
-                                "handles": old_action_configs.get(f"auto-{k}", {}).get("handles", []),
-                                "placeholder_keys": {
-                                    i["name"]: (
-                                        "unilabos_resources"
-                                        if i["type"] == "unilabos.registry.placeholder_type:ResourceSlot"
-                                        or i["type"] == ("list", "unilabos.registry.placeholder_type:ResourceSlot")
-                                        else "unilabos_devices"
-                                    )
-                                    for i in v["args"]
-                                    if i.get("type", "")
-                                    in [
-                                        "unilabos.registry.placeholder_type:ResourceSlot",
-                                        "unilabos.registry.placeholder_type:DeviceSlot",
-                                        ("list", "unilabos.registry.placeholder_type:ResourceSlot"),
-                                        ("list", "unilabos.registry.placeholder_type:DeviceSlot"),
-                                    ]
-                                },
-                            }
-                            for k, v in enhanced_info["action_methods"].items()
-                            if k not in device_config["class"]["action_value_mappings"]
-                        }
-                    )
-                    for action_name, old_config in old_action_configs.items():
-                        if action_name in device_config["class"]["action_value_mappings"]:
-                            old_schema = old_config.get("schema", {})
-                            if "description" in old_schema and old_schema["description"]:
-                                device_config["class"]["action_value_mappings"][action_name]["schema"][
-                                    "description"
-                                ] = old_schema["description"]
-                    device_config["init_param_schema"] = {}
-                    device_config["init_param_schema"]["config"] = self._generate_unilab_json_command_schema(
-                        enhanced_info["init_params"], "__init__"
-                    )["properties"]["goal"]
-                    device_config["init_param_schema"]["data"] = self._generate_status_types_schema(
-                        enhanced_info["status_methods"]
-                    )
-
-                device_config.pop("schema", None)
-                device_config["class"]["action_value_mappings"] = dict(
-                    sorted(device_config["class"]["action_value_mappings"].items())
-                )
-                for action_name, action_config in device_config["class"]["action_value_mappings"].items():
-                    if "handles" not in action_config:
-                        action_config["handles"] = {}
-                    elif isinstance(action_config["handles"], list):
-                        if len(action_config["handles"]):
-                            logger.error(f"设备{device_id} {action_name} 的handles配置错误，应该是字典类型")
-                            continue
-                        else:
-                            action_config["handles"] = {}
-                    if "type" in action_config:
-                        action_type_str: str = action_config["type"]
-                        if not action_type_str.startswith("UniLabJsonCommand"):
-                            try:
-                                target_type = self._replace_type_with_class(
-                                    action_type_str, device_id, f"动作 {action_name}"
-                                )
-                            except ROSMsgNotFound:
-                                continue
-                            action_str_type_mapping[action_type_str] = target_type
-                            if target_type is not None:
-                                action_config["goal_default"] = yaml.safe_load(
-                                    io.StringIO(get_yaml_from_goal_type(target_type.Goal))
-                                )
-                                action_config["schema"] = ros_action_to_json_schema(target_type)
-                            else:
-                                logger.warning(
-                                    f"[UniLab Registry] 设备 {device_id} 的动作 {action_name} 类型为空，跳过替换"
-                                )
-                complete_data[device_id] = copy.deepcopy(dict(sorted(device_config.items())))
-                for status_name, status_type in device_config["class"]["status_types"].items():
-                    device_config["class"]["status_types"][status_name] = status_str_type_mapping[status_type]
-                for action_name, action_config in device_config["class"]["action_value_mappings"].items():
-                    if action_config["type"] not in action_str_type_mapping:
-                        continue
-                    action_config["type"] = action_str_type_mapping[action_config["type"]]
-                self._add_builtin_actions(device_config, device_id)
-            device_config["file_path"] = str(file.absolute()).replace("\\", "/")
-            device_config["registry_type"] = "device"
-            device_ids.append(device_id)
-
-        complete_data = dict(sorted(complete_data.items()))
-        complete_data = copy.deepcopy(complete_data)
-        try:
-            with open(file, "w", encoding="utf-8") as f:
-                yaml.dump(complete_data, f, allow_unicode=True, default_flow_style=False, Dumper=NoAliasDumper)
-        except Exception as e:
-            logger.warning(f"[UniLab Registry] 写入设备文件失败: {file}, 错误: {e}")
-
-        return data, complete_data, True, device_ids
-
     def load_device_types(self, path: os.PathLike, complete_registry: bool):
+        # return
         abs_path = Path(path).absolute()
         devices_path = abs_path / "devices"
         device_comms_path = abs_path / "device_comms"
         files = list(devices_path.glob("*.yaml")) + list(device_comms_path.glob("*.yaml"))
-        logger.trace(
+        logger.trace(  # type: ignore
             f"[UniLab Registry] devices: {devices_path.exists()}, device_comms: {device_comms_path.exists()}, "
             + f"total: {len(files)}"
         )
-
+        current_device_number = len(self.device_type_registry) + 1
-        if not files:
-            return
-
         from unilabos.app.web.utils.action_utils import get_yaml_from_goal_type
 
-        # 使用线程池并行加载
+        for i, file in enumerate(files):
-        max_workers = min(8, len(files))
+            with open(file, encoding="utf-8", mode="r") as f:
-        results = []
+                data = yaml.safe_load(io.StringIO(f.read()))
-
+            complete_data = {}
-        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            action_str_type_mapping = {
-            future_to_file = {
+                "UniLabJsonCommand": "UniLabJsonCommand",
-                executor.submit(self._load_single_device_file, file, complete_registry, get_yaml_from_goal_type): file
+                "UniLabJsonCommandAsync": "UniLabJsonCommandAsync",
-                for file in files
             }
-            for future in as_completed(future_to_file):
+            status_str_type_mapping = {}
-                file = future_to_file[future]
+            if data:
-                try:
+                # 在添加到注册表前处理类型替换
-                    data, complete_data, is_valid, device_ids = future.result()
+                for device_id, device_config in data.items():
-                    if is_valid:
+                    # 添加文件路径信息 - 使用规范化的完整文件路径
-                        results.append((file, data, device_ids))
+                    if "version" not in device_config:
-                except Exception as e:
+                        device_config["version"] = "1.0.0"
-                    logger.warning(f"[UniLab Registry] 处理设备文件异常: {file}, 错误: {e}")
+                    if "category" not in device_config:
+                        device_config["category"] = [file.stem]
+                    elif file.stem not in device_config["category"]:
+                        device_config["category"].append(file.stem)
+                    if "config_info" not in device_config:
+                        device_config["config_info"] = []
+                    if "description" not in device_config:
+                        device_config["description"] = ""
+                    if "icon" not in device_config:
+                        device_config["icon"] = ""
+                    if "handles" not in device_config:
+                        device_config["handles"] = []
+                    if "init_param_schema" not in device_config:
+                        device_config["init_param_schema"] = {}
+                    if "class" in device_config:
+                        if (
+                            "status_types" not in device_config["class"]
+                            or device_config["class"]["status_types"] is None
+                        ):
+                            device_config["class"]["status_types"] = {}
+                        if (
+                            "action_value_mappings" not in device_config["class"]
+                            or device_config["class"]["action_value_mappings"] is None
+                        ):
+                            device_config["class"]["action_value_mappings"] = {}
+                        enhanced_info = {}
+                        if complete_registry:
+                            device_config["class"]["status_types"].clear()
+                            enhanced_info = get_enhanced_class_info(device_config["class"]["module"], use_dynamic=True)
+                            if not enhanced_info.get("dynamic_import_success", False):
+                                continue
+                            device_config["class"]["status_types"].update(
+                                {k: v["return_type"] for k, v in enhanced_info["status_methods"].items()}
+                            )
+                        for status_name, status_type in device_config["class"]["status_types"].items():
+                            if isinstance(status_type, tuple) or status_type in ["Any", "None", "Unknown"]:
+                                status_type = "String"  # 替换成ROS的String，便于显示
+                                device_config["class"]["status_types"][status_name] = status_type
+                            try:
+                                target_type = self._replace_type_with_class(
+                                    status_type, device_id, f"状态 {status_name}"
+                                )
+                            except ROSMsgNotFound:
+                                continue
+                            if target_type in [
+                                dict,
+                                list,
+                            ]:  # 对于嵌套类型返回的对象，暂时处理成字符串，无法直接进行转换
+                                target_type = String
+                            status_str_type_mapping[status_type] = target_type
+                        device_config["class"]["status_types"] = dict(
+                            sorted(device_config["class"]["status_types"].items())
+                        )
+                        if complete_registry:
+                            # 保存原有的 action 配置（用于保留 schema 的 description 和 handles 等）
+                            old_action_configs = {}
+                            for action_name, action_config in device_config["class"]["action_value_mappings"].items():
+                                old_action_configs[action_name] = action_config
 
-        # 线程安全地更新注册表
+                            device_config["class"]["action_value_mappings"] = {
-        current_device_number = len(self.device_type_registry) + 1
+                                k: v
-        with self._registry_lock:
+                                for k, v in device_config["class"]["action_value_mappings"].items()
-            for file, data, device_ids in results:
+                                if not k.startswith("auto-")
-                self.device_type_registry.update(data)
+                            }
-                for device_id in device_ids:
+                            # 处理动作值映射
-                    logger.trace(
+                            device_config["class"]["action_value_mappings"].update(
-                        f"[UniLab Registry] Device-{current_device_number} Add {device_id} "
+                                {
+                                    f"auto-{k}": {
+                                        "type": "UniLabJsonCommandAsync" if v["is_async"] else "UniLabJsonCommand",
+                                        "goal": {},
+                                        "feedback": {},
+                                        "result": {},
+                                        "schema": self._generate_unilab_json_command_schema(
+                                            v["args"],
+                                            k,
+                                            v.get("return_annotation"),
+                                            # 传入旧的 schema 以保留字段 description
+                                            old_action_configs.get(f"auto-{k}", {}).get("schema"),
+                                        ),
+                                        "goal_default": {i["name"]: i["default"] for i in v["args"]},
+                                        # 保留原有的 handles 配置
+                                        "handles": old_action_configs.get(f"auto-{k}", {}).get("handles", []),
+                                        "placeholder_keys": {
+                                            i["name"]: (
+                                                "unilabos_resources"
+                                                if i["type"] == "unilabos.registry.placeholder_type:ResourceSlot"
+                                                or i["type"]
+                                                == ("list", "unilabos.registry.placeholder_type:ResourceSlot")
+                                                else "unilabos_devices"
+                                            )
+                                            for i in v["args"]
+                                            if i.get("type", "")
+                                            in [
+                                                "unilabos.registry.placeholder_type:ResourceSlot",
+                                                "unilabos.registry.placeholder_type:DeviceSlot",
+                                                ("list", "unilabos.registry.placeholder_type:ResourceSlot"),
+                                                ("list", "unilabos.registry.placeholder_type:DeviceSlot"),
+                                            ]
+                                        },
+                                    }
+                                    # 不生成已配置action的动作
+                                    for k, v in enhanced_info["action_methods"].items()
+                                    if k not in device_config["class"]["action_value_mappings"]
+                                }
+                            )
+                            # 恢复原有的 description 信息（非 auto- 开头的动作）
+                            for action_name, old_config in old_action_configs.items():
+                                if action_name in device_config["class"]["action_value_mappings"]:  # 有一些会被删除
+                                    old_schema = old_config.get("schema", {})
+                                    if "description" in old_schema and old_schema["description"]:
+                                        device_config["class"]["action_value_mappings"][action_name]["schema"][
+                                            "description"
+                                        ] = old_schema["description"]
+                            device_config["init_param_schema"] = {}
+                            device_config["init_param_schema"]["config"] = self._generate_unilab_json_command_schema(
+                                enhanced_info["init_params"], "__init__"
+                            )["properties"]["goal"]
+                            device_config["init_param_schema"]["data"] = self._generate_status_types_schema(
+                                enhanced_info["status_methods"]
+                            )
+
+                        device_config.pop("schema", None)
+                        device_config["class"]["action_value_mappings"] = dict(
+                            sorted(device_config["class"]["action_value_mappings"].items())
+                        )
+                        for action_name, action_config in device_config["class"]["action_value_mappings"].items():
+                            if "handles" not in action_config:
+                                action_config["handles"] = {}
+                            elif isinstance(action_config["handles"], list):
+                                if len(action_config["handles"]):
+                                    logger.error(f"设备{device_id} {action_name} 的handles配置错误，应该是字典类型")
+                                    continue
+                                else:
+                                    action_config["handles"] = {}
+                            if "type" in action_config:
+                                action_type_str: str = action_config["type"]
+                                # 通过Json发放指令，而不是通过特殊的ros action进行处理
+                                if not action_type_str.startswith("UniLabJsonCommand"):
+                                    try:
+                                        target_type = self._replace_type_with_class(
+                                            action_type_str, device_id, f"动作 {action_name}"
+                                        )
+                                    except ROSMsgNotFound:
+                                        continue
+                                    action_str_type_mapping[action_type_str] = target_type
+                                    if target_type is not None:
+                                        action_config["goal_default"] = yaml.safe_load(
+                                            io.StringIO(get_yaml_from_goal_type(target_type.Goal))
+                                        )
+                                        action_config["schema"] = ros_action_to_json_schema(target_type)
+                                    else:
+                                        logger.warning(
+                                            f"[UniLab Registry] 设备 {device_id} 的动作 {action_name} 类型为空，跳过替换"
+                                        )
+                        complete_data[device_id] = copy.deepcopy(dict(sorted(device_config.items())))  # 稍后dump到文件
+                        for status_name, status_type in device_config["class"]["status_types"].items():
+                            device_config["class"]["status_types"][status_name] = status_str_type_mapping[status_type]
+                        for action_name, action_config in device_config["class"]["action_value_mappings"].items():
+                            if action_config["type"] not in action_str_type_mapping:
+                                continue
+                            action_config["type"] = action_str_type_mapping[action_config["type"]]
+                        # 添加内置的驱动命令动作
+                        self._add_builtin_actions(device_config, device_id)
+                    device_config["file_path"] = str(file.absolute()).replace("\\", "/")
+                    device_config["registry_type"] = "device"
+                    logger.trace(  # type: ignore
+                        f"[UniLab Registry] Device-{current_device_number} File-{i+1}/{len(files)} Add {device_id} "
                         + f"[{data[device_id].get('name', '未命名设备')}]"
                     )
                     current_device_number += 1
-
+                complete_data = dict(sorted(complete_data.items()))
-        # 记录无效文件
+                complete_data = copy.deepcopy(complete_data)
-        valid_files = {r[0] for r in results}
+                with open(file, "w", encoding="utf-8") as f:
-        for file in files:
+                    yaml.dump(complete_data, f, allow_unicode=True, default_flow_style=False, Dumper=NoAliasDumper)
-            if file not in valid_files:
+                self.device_type_registry.update(data)
-                logger.debug(f"[UniLab Registry] Device File Not Valid YAML File: {file.absolute()}")
+            else:
+                logger.debug(
+                    f"[UniLab Registry] Device File-{i+1}/{len(files)} Not Valid YAML File: {file.absolute()}"
+                )
 
     def obtain_registry_device_info(self):
         devices = []

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
@@ -151,40 +151,12 @@ def canonicalize_links_ports(links: List[Dict[str, Any]], resource_tree_set: Res
     """
     # 构建 id 到 uuid 的映射
     id_to_uuid: Dict[str, str] = {}
-    uuid_to_id: Dict[str, str] = {}
     for node in resource_tree_set.all_nodes:
         id_to_uuid[node.res_content.id] = node.res_content.uuid
-        uuid_to_id[node.res_content.uuid] = node.res_content.id
-
-    # 第三遍处理：为每个 link 添加 source_uuid 和 target_uuid
-    for link in links:
-        source_id = link.get("source")
-        target_id = link.get("target")
-
-        # 添加 source_uuid
-        if source_id and source_id in id_to_uuid:
-            link["source_uuid"] = id_to_uuid[source_id]
-
-        # 添加 target_uuid
-        if target_id and target_id in id_to_uuid:
-            link["target_uuid"] = id_to_uuid[target_id]
-
-        source_uuid = link.get("source_uuid")
-        target_uuid = link.get("target_uuid")
-
-        # 添加 source_uuid
-        if source_uuid and source_uuid in uuid_to_id:
-            link["source"] = uuid_to_id[source_uuid]
-
-        # 添加 target_uuid
-        if target_uuid and target_uuid in uuid_to_id:
-            link["target"] = uuid_to_id[target_uuid]
 
     # 第一遍处理：将字符串类型的port转换为字典格式
     for link in links:
         port = link.get("port")
-        if port is None:
-            continue
         if link.get("type", "physical") == "physical":
             link["type"] = "fluid"
         if isinstance(port, int):
@@ -207,15 +179,13 @@ def canonicalize_links_ports(links: List[Dict[str, Any]], resource_tree_set: Res
             link["port"] = {link["source"]: None, link["target"]: None}
 
     # 构建边字典，键为(source节点, target节点)，值为对应的port信息
-    edges = {(link["source"], link["target"]): link["port"] for link in links if link.get("port")}
+    edges = {(link["source"], link["target"]): link["port"] for link in links}
 
     # 第二遍处理：填充反向边的dest信息
     delete_reverses = []
     for i, link in enumerate(links):
         s, t = link["source"], link["target"]
-        current_port = link.get("port")
+        current_port = link["port"]
-        if current_port is None:
-            continue
         if current_port.get(t) is None:
             reverse_key = (t, s)
             reverse_port = edges.get(reverse_key)
@@ -230,6 +200,20 @@ def canonicalize_links_ports(links: List[Dict[str, Any]], resource_tree_set: Res
                 current_port[t] = current_port[s]
     # 删除已被使用反向端口信息的反向边
     standardized_links = [link for i, link in enumerate(links) if i not in delete_reverses]
+
+    # 第三遍处理：为每个 link 添加 source_uuid 和 target_uuid
+    for link in standardized_links:
+        source_id = link.get("source")
+        target_id = link.get("target")
+
+        # 添加 source_uuid
+        if source_id and source_id in id_to_uuid:
+            link["source_uuid"] = id_to_uuid[source_id]
+
+        # 添加 target_uuid
+        if target_id and target_id in id_to_uuid:
+            link["target_uuid"] = id_to_uuid[target_id]
+
     return standardized_links
 
 
@@ -300,8 +284,6 @@ def modify_to_backend_format(data: list[dict[str, Any]]) -> list[dict[str, Any]]
             edge["sourceHandle"] = port[source]
         elif "source_port" in edge:
             edge["sourceHandle"] = edge.pop("source_port")
-        elif "source_handle" in edge:
-            edge["sourceHandle"] = edge.pop("source_handle")
         else:
             typ = edge.get("type")
             if typ == "communication":
@@ -310,8 +292,6 @@ def modify_to_backend_format(data: list[dict[str, Any]]) -> list[dict[str, Any]]
             edge["targetHandle"] = port[target]
         elif "target_port" in edge:
             edge["targetHandle"] = edge.pop("target_port")
-        elif "target_handle" in edge:
-            edge["targetHandle"] = edge.pop("target_handle")
         else:
             typ = edge.get("type")
             if typ == "communication":

unilabos/resources/resource_tracker.py

@@ -5,8 +5,6 @@ from pydantic import BaseModel, field_serializer, field_validator, ValidationErr
 from pydantic import Field
 from typing import List, Tuple, Any, Dict, Literal, Optional, cast, TYPE_CHECKING, Union
 
-from typing_extensions import TypedDict
-
 from unilabos.resources.plr_additional_res_reg import register
 from unilabos.utils.log import logger
 
@@ -16,26 +14,6 @@ if TYPE_CHECKING:
 
 
 EXTRA_CLASS = "unilabos_resource_class"
-EXTRA_SAMPLE_UUID = "sample_uuid"
-EXTRA_UNILABOS_SAMPLE_UUID = "unilabos_sample_uuid"
-
-# 函数参数名常量 - 用于自动注入 sample_uuids 列表
-PARAM_SAMPLE_UUIDS = "sample_uuids"
-
-# JSON Command 中的系统参数字段名
-JSON_UNILABOS_PARAM = "unilabos_param"
-
-# 返回值中的 samples 字段名
-RETURN_UNILABOS_SAMPLES = "unilabos_samples"
-
-# sample_uuids 参数类型 (用于 virtual bench 等设备添加 sample_uuids 参数)
-SampleUUIDsType = Dict[str, Optional["PLRResource"]]
-
-
-class LabSample(TypedDict):
-    sample_uuid: str
-    oss_path: str
-    extra: Dict[str, Any]
 
 
 class ResourceDictPositionSize(BaseModel):
@@ -91,8 +69,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, eg: container liquid data")
+    data: Dict[str, Any] = Field(description="Resource data")
-    extra: Dict[str, Any] = Field(description="Extra data, eg: slot index")
+    extra: Dict[str, Any] = Field(description="Extra data")
 
     @field_serializer("parent_uuid")
     def _serialize_parent(self, parent_uuid: Optional["ResourceDict"]):
@@ -551,7 +529,6 @@ class ResourceTreeSet(object):
                 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)

unilabos/ros/nodes/base_device_node.py

@@ -4,20 +4,8 @@ import json
 import threading
 import time
 import traceback
-from typing import (
+from typing import get_type_hints, TypeVar, Generic, Dict, Any, Type, TypedDict, Optional, List, TYPE_CHECKING, Union, \
-    get_type_hints,
+    Tuple
-    TypeVar,
-    Generic,
-    Dict,
-    Any,
-    Type,
-    TypedDict,
-    Optional,
-    List,
-    TYPE_CHECKING,
-    Union,
-    Tuple,
-)
 
 from concurrent.futures import ThreadPoolExecutor
 import asyncio
@@ -60,9 +48,6 @@ from unilabos.resources.resource_tracker import (
     ResourceTreeSet,
     ResourceTreeInstance,
     ResourceDictInstance,
-    EXTRA_SAMPLE_UUID,
-    PARAM_SAMPLE_UUIDS,
-    JSON_UNILABOS_PARAM,
 )
 from unilabos.ros.utils.driver_creator import WorkstationNodeCreator, PyLabRobotCreator, DeviceClassCreator
 from rclpy.task import Task, Future
@@ -231,15 +216,14 @@ class PropertyPublisher:
 
     def publish_property(self):
         try:
-            # self.node.lab_logger().trace(f"【.publish_property】开始发布属性: {self.name}")
+            self.node.lab_logger().trace(f"【.publish_property】开始发布属性: {self.name}")
             value = self.get_property()
             if self.print_publish:
-                pass
+                self.node.lab_logger().trace(f"【.publish_property】发布 {self.msg_type}: {value}")
-                # self.node.lab_logger().trace(f"【.publish_property】发布 {self.msg_type}: {value}")
             if value is not None:
                 msg = convert_to_ros_msg(self.msg_type, value)
                 self.publisher_.publish(msg)
-                # self.node.lab_logger().trace(f"【.publish_property】属性 {self.name} 发布成功")
+                self.node.lab_logger().trace(f"【.publish_property】属性 {self.name} 发布成功")
         except Exception as e:
             self.node.lab_logger().error(
                 f"【.publish_property】发布属性 {self.publisher_.topic} 出错: {str(e)}\n{traceback.format_exc()}"
@@ -377,7 +361,6 @@ class BaseROS2DeviceNode(Node, Generic[T]):
             from pylabrobot.resources.deck import Deck
             from pylabrobot.resources import Coordinate
             from pylabrobot.resources import Plate
-
             # 物料传输到对应的node节点
             client = self._resource_clients["c2s_update_resource_tree"]
             request = SerialCommand.Request()
@@ -405,27 +388,33 @@ class BaseROS2DeviceNode(Node, Generic[T]):
             rts: ResourceTreeSet = ResourceTreeSet.from_raw_dict_list(input_resources)
             parent_resource = None
             if bind_parent_id != self.node_name:
-                parent_resource = self.resource_tracker.figure_resource({"name": bind_parent_id})
+                parent_resource = self.resource_tracker.figure_resource(
+                    {"name": bind_parent_id}
+                )
                 for r in rts.root_nodes:
                     # noinspection PyUnresolvedReferences
                     r.res_content.parent_uuid = parent_resource.unilabos_uuid
             else:
                 for r in rts.root_nodes:
                     r.res_content.parent_uuid = self.uuid
-            rts_plr_instances = rts.to_plr_resources()
+
-            if len(rts.root_nodes) == 1 and isinstance(rts_plr_instances[0], RegularContainer):
+            if len(LIQUID_INPUT_SLOT) and LIQUID_INPUT_SLOT[0] == -1 and len(rts.root_nodes) == 1 and isinstance(rts.root_nodes[0], RegularContainer):
                 # noinspection PyTypeChecker
-                container_instance: RegularContainer = rts_plr_instances[0]
+                container_instance: RegularContainer = rts.root_nodes[0]
-                found_resources = self.resource_tracker.figure_resource({"name": container_instance.name}, try_mode=True)
+                found_resources = self.resource_tracker.figure_resource(
+                    {"id": container_instance.name}, try_mode=True
+                )
                 if not len(found_resources):
                     self.resource_tracker.add_resource(container_instance)
                     logger.info(f"添加物料{container_instance.name}到资源跟踪器")
                 else:
-                    assert len(found_resources) == 1, f"找到多个同名物料: {container_instance.name}, 请检查物料系统"
+                    assert (
+                        len(found_resources) == 1
+                    ), f"找到多个同名物料: {container_instance.name}, 请检查物料系统"
                     found_resource = found_resources[0]
                     if isinstance(found_resource, RegularContainer):
                         logger.info(f"更新物料{container_instance.name}的数据{found_resource.state}")
-                        found_resource.state.update(container_instance.state)
+                        found_resource.state.update(json.loads(container_instance.state))
                     elif isinstance(found_resource, dict):
                         raise ValueError("已不支持 字典 版本的RegularContainer")
                     else:
@@ -433,16 +422,14 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                             f"更新物料{container_instance.name}出现不支持的数据类型{type(found_resource)} {found_resource}"
                         )
             # noinspection PyUnresolvedReferences
-            request.command = json.dumps(
+            request.command = json.dumps({
-                {
+                "action": "add",
-                    "action": "add",
+                "data": {
-                    "data": {
+                    "data": rts.dump(),
-                        "data": rts.dump(),
+                    "mount_uuid": parent_resource.unilabos_uuid if parent_resource is not None else "",
-                        "mount_uuid": parent_resource.unilabos_uuid if parent_resource is not None else self.uuid,
+                    "first_add": False,
-                        "first_add": False,
+                },
-                    },
+            })
-                }
-            )
             tree_response: SerialCommand.Response = await client.call_async(request)
             uuid_maps = json.loads(tree_response.response)
             plr_instances = rts.to_plr_resources()
@@ -484,9 +471,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                         if len(ADD_LIQUID_TYPE) == 1 and len(LIQUID_VOLUME) == 1 and len(LIQUID_INPUT_SLOT) > 1:
                             ADD_LIQUID_TYPE = ADD_LIQUID_TYPE * len(LIQUID_INPUT_SLOT)
                             LIQUID_VOLUME = LIQUID_VOLUME * len(LIQUID_INPUT_SLOT)
-                            self.lab_logger().warning(
+                            self.lab_logger().warning(f"增加液体资源时，数量为1，自动补全为 {len(LIQUID_INPUT_SLOT)} 个")
-                                f"增加液体资源时，数量为1，自动补全为 {len(LIQUID_INPUT_SLOT)} 个"
-                            )
                         for liquid_type, liquid_volume, liquid_input_slot in zip(
                             ADD_LIQUID_TYPE, LIQUID_VOLUME, LIQUID_INPUT_SLOT
                         ):
@@ -505,15 +490,9 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                             input_wells = []
                             for r in LIQUID_INPUT_SLOT:
                                 input_wells.append(plr_instance.children[r])
-                        final_response["liquid_input_resource_tree"] = ResourceTreeSet.from_plr_resources(
+                        final_response["liquid_input_resource_tree"] = ResourceTreeSet.from_plr_resources(input_wells).dump()
-                            input_wells
-                        ).dump()
                         res.response = json.dumps(final_response)
-                    if (
+                    if issubclass(parent_resource.__class__, Deck) and hasattr(parent_resource, "assign_child_at_slot") and "slot" in other_calling_param:
-                        issubclass(parent_resource.__class__, Deck)
-                        and hasattr(parent_resource, "assign_child_at_slot")
-                        and "slot" in other_calling_param
-                    ):
                         other_calling_param["slot"] = int(other_calling_param["slot"])
                         parent_resource.assign_child_at_slot(plr_instance, **other_calling_param)
                     else:
@@ -528,16 +507,14 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                     rts_with_parent = ResourceTreeSet.from_plr_resources([parent_resource])
                     if rts_with_parent.root_nodes[0].res_content.uuid_parent is None:
                         rts_with_parent.root_nodes[0].res_content.parent_uuid = self.uuid
-                    request.command = json.dumps(
+                    request.command = json.dumps({
-                        {
+                        "action": "add",
-                            "action": "add",
+                        "data": {
-                            "data": {
+                            "data": rts_with_parent.dump(),
-                                "data": rts_with_parent.dump(),
+                            "mount_uuid": rts_with_parent.root_nodes[0].res_content.uuid_parent,
-                                "mount_uuid": rts_with_parent.root_nodes[0].res_content.uuid_parent,
+                            "first_add": False,
-                                "first_add": False,
+                        },
-                            },
+                    })
-                        }
-                    )
                     tree_response: SerialCommand.Response = await client.call_async(request)
                     uuid_maps = json.loads(tree_response.response)
                     self.resource_tracker.loop_update_uuid(input_resources, uuid_maps)
@@ -834,9 +811,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):
             }
 
         def _handle_update(
-            plr_resources: List[Union[ResourcePLR, ResourceDictInstance]],
+            plr_resources: List[Union[ResourcePLR, ResourceDictInstance]], tree_set: ResourceTreeSet, additional_add_params: Dict[str, Any]
-            tree_set: ResourceTreeSet,
-            additional_add_params: Dict[str, Any],
         ) -> Tuple[Dict[str, Any], List[ResourcePLR]]:
             """
             处理资源更新操作的内部函数
@@ -861,10 +836,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                 original_parent_resource = original_instance.parent
                 original_parent_resource_uuid = getattr(original_parent_resource, "unilabos_uuid", None)
                 target_parent_resource_uuid = tree.root_node.res_content.uuid_parent
-                not_same_parent = (
+                not_same_parent = original_parent_resource_uuid != target_parent_resource_uuid and original_parent_resource is not None
-                    original_parent_resource_uuid != target_parent_resource_uuid
-                    and original_parent_resource is not None
-                )
                 old_name = original_instance.name
                 new_name = plr_resource.name
                 parent_appended = False
@@ -900,16 +872,8 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                 else:
                     # 判断是否变更了resource_site，重新登记
                     target_site = original_instance.unilabos_extra.get("update_resource_site")
-                    sites = (
+                    sites = original_instance.parent.sites if original_instance.parent is not None and hasattr(original_instance.parent, "sites") else None
-                        original_instance.parent.sites
+                    site_names = list(original_instance.parent._ordering.keys()) if original_instance.parent is not None and hasattr(original_instance.parent, "sites") else []
-                        if original_instance.parent is not None and hasattr(original_instance.parent, "sites")
-                        else None
-                    )
-                    site_names = (
-                        list(original_instance.parent._ordering.keys())
-                        if original_instance.parent is not None and hasattr(original_instance.parent, "sites")
-                        else []
-                    )
                     if target_site is not None and sites is not None and site_names is not None:
                         site_index = sites.index(original_instance)
                         site_name = site_names[site_index]
@@ -946,7 +910,9 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                 action = i.get("action")  # remove, add, update
                 resources_uuid: List[str] = i.get("data")  # 资源数据
                 additional_add_params = i.get("additional_add_params", {})  # 额外参数
-                self.lab_logger().trace(f"[资源同步] 处理 {action}, " f"resources count: {len(resources_uuid)}")
+                self.lab_logger().trace(
+                    f"[资源同步] 处理 {action}, " f"resources count: {len(resources_uuid)}"
+                )
                 tree_set = None
                 if action in ["add", "update"]:
                     tree_set = await self.get_resource(
@@ -973,13 +939,9 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                                 tree.root_node.res_content.parent_uuid = self.uuid
                         r = SerialCommand.Request()
                         r.command = json.dumps(
-                            {"data": {"data": new_tree_set.dump()}, "action": "update"}
+                            {"data": {"data": new_tree_set.dump()}, "action": "update"})  # 和Update Resource一致
-                        )  # 和Update Resource一致
                         response: SerialCommand_Response = await self._resource_clients[
-                            "c2s_update_resource_tree"
+                            "c2s_update_resource_tree"].call_async(r)  # type: ignore
-                        ].call_async(
-                            r
-                        )  # type: ignore
                         self.lab_logger().info(f"确认资源云端 Add 结果: {response.response}")
                         results.append(result)
                     elif action == "update":
@@ -999,13 +961,9 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                                     tree.root_node.res_content.parent_uuid = self.uuid
                             r = SerialCommand.Request()
                             r.command = json.dumps(
-                                {"data": {"data": new_tree_set.dump()}, "action": "update"}
+                                {"data": {"data": new_tree_set.dump()}, "action": "update"})  # 和Update Resource一致
-                            )  # 和Update Resource一致
                             response: SerialCommand_Response = await self._resource_clients[
-                                "c2s_update_resource_tree"
+                                "c2s_update_resource_tree"].call_async(r)  # type: ignore
-                            ].call_async(
-                                r
-                            )  # type: ignore
                             self.lab_logger().info(f"确认资源云端 Update 结果: {response.response}")
                         results.append(result)
                     elif action == "remove":
@@ -1375,7 +1333,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                                         resource_id=resource_data["id"], with_children=True
                                     )
                                     if "sample_id" in resource_data:
-                                        plr_resource.unilabos_extra[EXTRA_SAMPLE_UUID] = resource_data["sample_id"]
+                                        plr_resource.unilabos_extra["sample_uuid"] = resource_data["sample_id"]
                                     queried_resources[idx] = plr_resource
                                 else:
                                     uuid_indices.append((idx, unilabos_uuid, resource_data))
@@ -1388,7 +1346,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                                 for i, (idx, _, resource_data) in enumerate(uuid_indices):
                                     plr_resource = plr_resources[i]
                                     if "sample_id" in resource_data:
-                                        plr_resource.unilabos_extra[EXTRA_SAMPLE_UUID] = resource_data["sample_id"]
+                                        plr_resource.unilabos_extra["sample_uuid"] = resource_data["sample_id"]
                                     queried_resources[idx] = plr_resource
 
                             self.lab_logger().debug(f"资源查询结果: 共 {len(queried_resources)} 个资源")
@@ -1396,9 +1354,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                             # 通过资源跟踪器获取本地实例
                             final_resources = queried_resources if is_sequence else queried_resources[0]
                             if not is_sequence:
-                                plr = self.resource_tracker.figure_resource(
+                                plr = self.resource_tracker.figure_resource({"name": final_resources.name}, try_mode=False)
-                                    {"name": final_resources.name}, try_mode=False
-                                )
                                 # 保留unilabos_extra
                                 if hasattr(final_resources, "unilabos_extra") and hasattr(plr, "unilabos_extra"):
                                     plr.unilabos_extra = getattr(final_resources, "unilabos_extra", {}).copy()
@@ -1437,12 +1393,8 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                                 execution_success = True
                             except Exception as _:
                                 execution_error = traceback.format_exc()
-                                error(
+                                error(f"异步任务 {ACTION.__name__} 报错了\n{traceback.format_exc()}\n原始输入：{str(action_kwargs)[:1000]}")
-                                    f"异步任务 {ACTION.__name__} 报错了\n{traceback.format_exc()}\n原始输入：{str(action_kwargs)[:1000]}"
+                                trace(f"异步任务 {ACTION.__name__} 报错了\n{traceback.format_exc()}\n原始输入：{action_kwargs}")
-                                )
-                                trace(
-                                    f"异步任务 {ACTION.__name__} 报错了\n{traceback.format_exc()}\n原始输入：{action_kwargs}"
-                                )
 
                         future = ROS2DeviceNode.run_async_func(ACTION, trace_error=False, **action_kwargs)
                         future.add_done_callback(_handle_future_exception)
@@ -1462,11 +1414,9 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                         except Exception as _:
                             execution_error = traceback.format_exc()
                             error(
-                                f"同步任务 {ACTION.__name__} 报错了\n{traceback.format_exc()}\n原始输入：{str(action_kwargs)[:1000]}"
+                                f"同步任务 {ACTION.__name__} 报错了\n{traceback.format_exc()}\n原始输入：{str(action_kwargs)[:1000]}")
-                            )
                             trace(
-                                f"同步任务 {ACTION.__name__} 报错了\n{traceback.format_exc()}\n原始输入：{action_kwargs}"
+                                f"同步任务 {ACTION.__name__} 报错了\n{traceback.format_exc()}\n原始输入：{action_kwargs}")
-                            )
 
                     future.add_done_callback(_handle_future_exception)
 
@@ -1533,18 +1483,11 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                             if isinstance(rs, list):
                                 for r in rs:
                                     res = self.resource_tracker.parent_resource(r)  # 获取 resource 对象
-                                    if res is None:
-                                        res = rs
-                                    if id(res) not in seen:
-                                        seen.add(id(res))
-                                        unique_resources.append(res)
                             else:
                                 res = self.resource_tracker.parent_resource(rs)
-                                if res is None:
+                            if id(res) not in seen:
-                                    res = rs
+                                seen.add(id(res))
-                                if id(res) not in seen:
+                                unique_resources.append(res)
-                                    seen.add(id(res))
-                                    unique_resources.append(res)
 
                         # 使用新的资源树接口
                         if unique_resources:
@@ -1596,39 +1539,20 @@ class BaseROS2DeviceNode(Node, Generic[T]):
         try:
             function_name = target["function_name"]
             function_args = target["function_args"]
-            # 获取 unilabos 系统参数
-            unilabos_param: Dict[str, Any] = target[JSON_UNILABOS_PARAM]
-
             assert isinstance(function_args, dict), "执行动作时JSON必须为dict类型\n原JSON: {string}"
             function = getattr(self.driver_instance, function_name)
             assert callable(
                 function
             ), f"执行动作时JSON中的function_name对应的函数不可调用: {function_name}\n原JSON: {string}"
 
-            # 处理参数（包含 unilabos 系统参数如 sample_uuids）
+            # 处理 ResourceSlot 类型参数
-            args_list = default_manager._analyze_method_signature(function, skip_unilabos_params=False)["args"]
+            args_list = default_manager._analyze_method_signature(function)["args"]
             for arg in args_list:
                 arg_name = arg["name"]
                 arg_type = arg["type"]
 
                 # 跳过不在 function_args 中的参数
                 if arg_name not in function_args:
-                    # 处理 sample_uuids 参数注入
-                    if arg_name == PARAM_SAMPLE_UUIDS:
-                        raw_sample_uuids = unilabos_param.get(PARAM_SAMPLE_UUIDS, {})
-                        # 将 material uuid 转换为 resource 实例
-                        # key: sample_uuid, value: material_uuid -> resource 实例
-                        resolved_sample_uuids: Dict[str, Any] = {}
-                        for sample_uuid, material_uuid in raw_sample_uuids.items():
-                            if material_uuid and self.resource_tracker:
-                                resource = self.resource_tracker.uuid_to_resources.get(material_uuid)
-                                resolved_sample_uuids[sample_uuid] = resource if resource else material_uuid
-                            else:
-                                resolved_sample_uuids[sample_uuid] = material_uuid
-                        function_args[PARAM_SAMPLE_UUIDS] = resolved_sample_uuids
-                        self.lab_logger().debug(
-                            f"[JsonCommand] 注入 {PARAM_SAMPLE_UUIDS}: {resolved_sample_uuids}"
-                        )
                     continue
 
                 # 处理单个 ResourceSlot
@@ -1658,7 +1582,6 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                                 )
                                 raise JsonCommandInitError(f"ResourceSlot列表参数转换失败: {arg_name}")
 
-            # todo: 默认反报送
             return function(**function_args)
         except KeyError as ex:
             raise JsonCommandInitError(
@@ -1678,23 +1601,21 @@ class BaseROS2DeviceNode(Node, Generic[T]):
             raise ValueError("至少需要提供一个 UUID")
 
         uuids_list = list(uuids)
-        future = self._resource_clients["c2s_update_resource_tree"].call_async(
+        future = self._resource_clients["c2s_update_resource_tree"].call_async(SerialCommand.Request(
-            SerialCommand.Request(
+            command=json.dumps(
-                command=json.dumps(
+                {
-                    {
+                    "data": {"data": uuids_list, "with_children": True},
-                        "data": {"data": uuids_list, "with_children": True},
+                    "action": "get",
-                        "action": "get",
+                }
-                    }
-                )
             )
-        )
+        ))
 
         # 等待结果（使用while循环，每次sleep 0.05秒，最多等待30秒）
         timeout = 30.0
         elapsed = 0.0
         while not future.done() and elapsed < timeout:
-            time.sleep(0.02)
+            time.sleep(0.05)
-            elapsed += 0.02
+            elapsed += 0.05
 
         if not future.done():
             raise Exception(f"资源查询超时: {uuids_list}")
@@ -1745,9 +1666,6 @@ class BaseROS2DeviceNode(Node, Generic[T]):
         try:
             function_name = target["function_name"]
             function_args = target["function_args"]
-            # 获取 unilabos 系统参数
-            unilabos_param: Dict[str, Any] = target.get(JSON_UNILABOS_PARAM, {})
-
             assert isinstance(function_args, dict), "执行动作时JSON必须为dict类型\n原JSON: {string}"
             function = getattr(self.driver_instance, function_name)
             assert callable(
@@ -1757,30 +1675,14 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                 function
             ), f"执行动作时JSON中的function并非异步: {function_name}\n原JSON: {string}"
 
-            # 处理参数（包含 unilabos 系统参数如 sample_uuids）
+            # 处理 ResourceSlot 类型参数
-            args_list = default_manager._analyze_method_signature(function, skip_unilabos_params=False)["args"]
+            args_list = default_manager._analyze_method_signature(function)["args"]
             for arg in args_list:
                 arg_name = arg["name"]
                 arg_type = arg["type"]
 
                 # 跳过不在 function_args 中的参数
                 if arg_name not in function_args:
-                    # 处理 sample_uuids 参数注入
-                    if arg_name == PARAM_SAMPLE_UUIDS:
-                        raw_sample_uuids = unilabos_param.get(PARAM_SAMPLE_UUIDS, {})
-                        # 将 material uuid 转换为 resource 实例
-                        # key: sample_uuid, value: material_uuid -> resource 实例
-                        resolved_sample_uuids: Dict[str, Any] = {}
-                        for sample_uuid, material_uuid in raw_sample_uuids.items():
-                            if material_uuid and self.resource_tracker:
-                                resource = self.resource_tracker.uuid_to_resources.get(material_uuid)
-                                resolved_sample_uuids[sample_uuid] = resource if resource else material_uuid
-                            else:
-                                resolved_sample_uuids[sample_uuid] = material_uuid
-                        function_args[PARAM_SAMPLE_UUIDS] = resolved_sample_uuids
-                        self.lab_logger().debug(
-                            f"[JsonCommandAsync] 注入 {PARAM_SAMPLE_UUIDS}: {resolved_sample_uuids}"
-                        )
                     continue
 
                 # 处理单个 ResourceSlot
@@ -2058,9 +1960,7 @@ class ROS2DeviceNode:
             asyncio.set_event_loop(loop)
             loop.run_forever()
 
-        ROS2DeviceNode._asyncio_loop_thread = threading.Thread(
+        ROS2DeviceNode._asyncio_loop_thread = threading.Thread(target=run_event_loop, daemon=True, name="ROS2DeviceNode")
-            target=run_event_loop, daemon=True, name="ROS2DeviceNode"
-        )
         ROS2DeviceNode._asyncio_loop_thread.start()
         logger.info(f"循环线程已启动")
 

unilabos/ros/nodes/presets/host_node.py

@@ -1,17 +1,17 @@
 import collections
+from dataclasses import dataclass, field
 import json
 import threading
 import time
 import traceback
 import uuid
-from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Optional, Dict, Any, List, ClassVar, Set, Union
+from typing_extensions import TypedDict
 
 from action_msgs.msg import GoalStatus
 from geometry_msgs.msg import Point
 from rclpy.action import ActionClient, get_action_server_names_and_types_by_node
 from rclpy.service import Service
-from typing_extensions import TypedDict
 from unilabos_msgs.msg import Resource  # type: ignore
 from unilabos_msgs.srv import (
     ResourceAdd,
@@ -23,20 +23,10 @@ from unilabos_msgs.srv import (
 from unilabos_msgs.srv._serial_command import SerialCommand_Request, SerialCommand_Response
 from unique_identifier_msgs.msg import UUID
 
-from unilabos.registry.placeholder_type import ResourceSlot, DeviceSlot
 from unilabos.registry.registry import lab_registry
 from unilabos.resources.container import RegularContainer
 from unilabos.resources.graphio import initialize_resource
 from unilabos.resources.registry import add_schema
-from unilabos.resources.resource_tracker import (
-    ResourceDict,
-    ResourceDictInstance,
-    ResourceTreeSet,
-    ResourceTreeInstance,
-    RETURN_UNILABOS_SAMPLES,
-    JSON_UNILABOS_PARAM,
-    PARAM_SAMPLE_UUIDS,
-)
 from unilabos.ros.initialize_device import initialize_device_from_dict
 from unilabos.ros.msgs.message_converter import (
     get_msg_type,
@@ -47,10 +37,17 @@ from unilabos.ros.msgs.message_converter import (
 )
 from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode, ROS2DeviceNode, DeviceNodeResourceTracker
 from unilabos.ros.nodes.presets.controller_node import ControllerNode
+from unilabos.resources.resource_tracker import (
+    ResourceDict,
+    ResourceDictInstance,
+    ResourceTreeSet,
+    ResourceTreeInstance,
+)
 from unilabos.utils import logger
 from unilabos.utils.exception import DeviceClassInvalid
 from unilabos.utils.log import warning
 from unilabos.utils.type_check import serialize_result_info
+from unilabos.registry.placeholder_type import ResourceSlot, DeviceSlot
 
 if TYPE_CHECKING:
     from unilabos.app.ws_client import QueueItem
@@ -758,7 +755,6 @@ class HostNode(BaseROS2DeviceNode):
         item: "QueueItem",
         action_type: str,
         action_kwargs: Dict[str, Any],
-        sample_material: Dict[str, str],
         server_info: Optional[Dict[str, Any]] = None,
     ) -> None:
         """
@@ -776,14 +772,14 @@ class HostNode(BaseROS2DeviceNode):
             if action_name.startswith("auto-"):
                 action_name = action_name[5:]
             action_id = f"/devices/{device_id}/_execute_driver_command"
-            json_command: Dict[str, Any] = {
+            action_kwargs = {
-                "function_name": action_name,
+                "string": json.dumps(
-                "function_args": action_kwargs,
+                    {
-                JSON_UNILABOS_PARAM: {
+                        "function_name": action_name,
-                    PARAM_SAMPLE_UUIDS: sample_material,
+                        "function_args": action_kwargs,
-                },
+                    }
+                )
             }
-            action_kwargs = {"string": json.dumps(json_command)}
             if action_type.startswith("UniLabJsonCommandAsync"):
                 action_id = f"/devices/{device_id}/_execute_driver_command_async"
         else:
@@ -794,9 +790,24 @@ class HostNode(BaseROS2DeviceNode):
             raise ValueError(f"ActionClient {action_id} not found.")
 
         action_client: ActionClient = self._action_clients[action_id]
+
+        # 遍历action_kwargs下的所有子dict，将"sample_uuid"的值赋给"sample_id"
+        def assign_sample_id(obj):
+            if isinstance(obj, dict):
+                if "sample_uuid" in obj:
+                    obj["sample_id"] = obj["sample_uuid"]
+                    obj.pop("sample_uuid")
+                for k, v in obj.items():
+                    if k != "unilabos_extra":
+                        assign_sample_id(v)
+            elif isinstance(obj, list):
+                for item in obj:
+                    assign_sample_id(item)
+
+        assign_sample_id(action_kwargs)
         goal_msg = convert_to_ros_msg(action_client._action_type.Goal(), action_kwargs)
 
-        # self.lab_logger().trace(f"[Host Node] Sending goal for {action_id}: {str(goal_msg)[:1000]}")
+        self.lab_logger().info(f"[Host Node] Sending goal for {action_id}: {str(goal_msg)[:1000]}")
         self.lab_logger().trace(f"[Host Node] Sending goal for {action_id}: {action_kwargs}")
         self.lab_logger().trace(f"[Host Node] Sending goal for {action_id}: {goal_msg}")
         action_client.wait_for_server()
@@ -856,14 +867,14 @@ class HostNode(BaseROS2DeviceNode):
                         # 适配后端的一些额外处理
                         return_value = return_info.get("return_value")
                         if isinstance(return_value, dict):
-                            unilabos_samples = return_value.pop(RETURN_UNILABOS_SAMPLES, None)
+                            unilabos_samples = return_value.pop("unilabos_samples", None)
                             if isinstance(unilabos_samples, list) and unilabos_samples:
                                 self.lab_logger().info(
                                     f"[Host Node] Job {job_id[:8]} returned {len(unilabos_samples)} sample(s): "
                                     f"{[s.get('name', s.get('id', 'unknown')) if isinstance(s, dict) else str(s)[:20] for s in unilabos_samples[:5]]}"
                                     f"{'...' if len(unilabos_samples) > 5 else ''}"
                                 )
-                                return_info["samples"] = unilabos_samples
+                                return_info["unilabos_samples"] = unilabos_samples
                         suc = return_info.get("suc", False)
                         if not suc:
                             status = "failed"
@@ -1169,7 +1180,7 @@ class HostNode(BaseROS2DeviceNode):
         """
         更新节点信息回调
         """
-        self.lab_logger().trace(f"[Host Node] Node info update request received: {request}")
+        # self.lab_logger().info(f"[Host Node] Node info update request received: {request}")
         try:
             from unilabos.app.communication import get_communication_client
             from unilabos.app.web.client import HTTPClient, http_client

unilabos/ros/nodes/presets/workstation.py

@@ -340,8 +340,6 @@ class ROS2WorkstationNode(BaseROS2DeviceNode):
                             plr = self.resource_tracker.figure_resource({"name": res_name}, try_mode=False)
                             # 获取父资源
                             res = self.resource_tracker.parent_resource(plr)
-                            if res is None:
-                                res = plr
                             if id(res) not in seen:
                                 seen.add(id(res))
                                 unique_resources.append(res)

unilabos/ros/utils/driver_creator.py

@@ -52,8 +52,7 @@ class DeviceClassCreator(Generic[T]):
         if self.device_instance is not None:
             for c in self.children:
                 if c.res_content.type != "device":
-                    res = ResourceTreeSet([ResourceTreeInstance(c)]).to_plr_resources()[0]
+                    self.resource_tracker.add_resource(c.get_plr_nested_dict())
-                    self.resource_tracker.add_resource(res)
 
     def create_instance(self, data: Dict[str, Any]) -> T:
         """
@@ -120,7 +119,7 @@ class PyLabRobotCreator(DeviceClassCreator[T]):
     #     return resource, source_type
 
     def _process_resource_references(
-        self, data: Any, processed_child_names: Optional[Dict[str, Any]], to_dict=False, states=None, prefix_path="", name_to_uuid=None
+        self, data: Any, to_dict=False, states=None, prefix_path="", name_to_uuid=None
     ) -> Any:
         """
         递归处理资源引用，替换_resource_child_name对应的资源
@@ -165,7 +164,6 @@ class PyLabRobotCreator(DeviceClassCreator[T]):
                                 states[prefix_path] = resource_instance.serialize_all_state()
                                 return serialized
                             else:
-                                processed_child_names[child_name] = resource_instance
                                 self.resource_tracker.add_resource(resource_instance)
                                 # 立即设置UUID，state已经在resource_ulab_to_plr中处理过了
                                 if name_to_uuid:
@@ -184,12 +182,12 @@ class PyLabRobotCreator(DeviceClassCreator[T]):
             result = {}
             for key, value in data.items():
                 new_prefix = f"{prefix_path}.{key}" if prefix_path else key
-                result[key] = self._process_resource_references(value, processed_child_names, to_dict, states, new_prefix, name_to_uuid)
+                result[key] = self._process_resource_references(value, to_dict, states, new_prefix, name_to_uuid)
             return result
 
         elif isinstance(data, list):
             return [
-                self._process_resource_references(item, processed_child_names, to_dict, states, f"{prefix_path}[{i}]", name_to_uuid)
+                self._process_resource_references(item, to_dict, states, f"{prefix_path}[{i}]", name_to_uuid)
                 for i, item in enumerate(data)
             ]
 
@@ -236,7 +234,7 @@ class PyLabRobotCreator(DeviceClassCreator[T]):
             # 首先处理资源引用
             states = {}
             processed_data = self._process_resource_references(
-                data, {}, to_dict=True, states=states, name_to_uuid=name_to_uuid
+                data, to_dict=True, states=states, name_to_uuid=name_to_uuid
             )
 
             try:
@@ -272,12 +270,7 @@ class PyLabRobotCreator(DeviceClassCreator[T]):
                         arg_value = spec_args[param_name].annotation
                         data[param_name]["_resource_type"] = self.device_cls.__module__ + ":" + arg_value
                         logger.debug(f"自动补充 _resource_type: {data[param_name]['_resource_type']}")
-                processed_child_names = {}
+                processed_data = self._process_resource_references(data, to_dict=False, name_to_uuid=name_to_uuid)
-                processed_data = self._process_resource_references(data, processed_child_names, to_dict=False, name_to_uuid=name_to_uuid)
-                for child_name, resource_instance in processed_data.items():
-                    for ind, name in enumerate([child.res_content.name for child in self.children]):
-                        if name == child_name:
-                            self.children.pop(ind)
                 self.device_instance = super(PyLabRobotCreator, self).create_instance(processed_data)  # 补全变量后直接调用，调用的自身的attach_resource
             except Exception as e:
                 logger.error(f"PyLabRobot创建实例失败: {e}")
@@ -349,10 +342,9 @@ class WorkstationNodeCreator(DeviceClassCreator[T]):
         try:
             # 创建实例，额外补充一个给protocol node的字段，后面考虑取消
             data["children"] = self.children
-            # super(WorkstationNodeCreator, self).create_instance(data)的时候会attach
+            for child in self.children:
-            # for child in self.children:
+                if child.res_content.type != "device":
-            #     if child.res_content.type != "device":
+                    self.resource_tracker.add_resource(child.get_plr_nested_dict())
-            #         self.resource_tracker.add_resource(child.get_plr_nested_dict())
             deck_dict = data.get("deck")
             if deck_dict:
                 from pylabrobot.resources import Deck, Resource

unilabos/test/experiments/prcxi_9320_slim.json

@@ -1,795 +0,0 @@
-{
-  "nodes": [
-    {
-      "id": "PRCXI",
-      "name": "PRCXI",
-      "type": "device",
-      "class": "liquid_handler.prcxi",
-      "parent": "",
-      "pose": {
-        "size": {
-          "width": 562,
-          "height": 394,
-          "depth": 0
-        }
-      },
-      "config": {
-        "axis": "Left",
-        "deck": {
-          "_resource_type": "unilabos.devices.liquid_handling.prcxi.prcxi:PRCXI9300Deck",
-          "_resource_child_name": "PRCXI_Deck"
-        },
-        "host": "10.20.30.184",
-        "port": 9999,
-        "debug": true,
-        "setup": true,
-        "is_9320": true,
-        "timeout": 10,
-        "matrix_id": "5de524d0-3f95-406c-86dd-f83626ebc7cb",
-        "simulator": true,
-        "channel_num": 2
-      },
-      "data": {
-        "reset_ok": true
-      },
-      "schema": {},
-      "description": "",
-      "model": null,
-      "position": {
-        "x": 0,
-        "y": 240,
-        "z": 0
-      }
-    },
-    {
-      "id": "PRCXI_Deck",
-      "name": "PRCXI_Deck",
-
-      "children": [],
-      "parent": "PRCXI",
-      "type": "deck",
-      "class": "",
-      "position": {
-        "x": 10,
-        "y": 10,
-        "z": 0
-      },
-      "config": {
-        "type": "PRCXI9300Deck",
-        "size_x": 542,
-        "size_y": 374,
-        "size_z": 0,
-        "rotation": {
-          "x": 0,
-          "y": 0,
-          "z": 0,
-          "type": "Rotation"
-        },
-        "category": "deck",
-        "barcode": null
-      },
-      "data": {}
-    },
-    {
-      "id": "T1",
-      "name": "T1",
-      "children": [],
-      "parent": "PRCXI_Deck",
-      "type": "plate",
-      "class": "",
-      "position": {
-        "x": 0,
-        "y": 288,
-        "z": 0
-      },
-      "config": {
-        "type": "PRCXI9300Container",
-        "size_x": 127,
-        "size_y": 85.5,
-        "size_z": 10,
-        "rotation": {
-          "x": 0,
-          "y": 0,
-          "z": 0,
-          "type": "Rotation"
-        },
-        "category": "plate",
-        "model": null,
-        "barcode": null,
-        "ordering": {},
-        "sites": [
-          {
-            "label": "T1",
-            "visible": true,
-            "position": { "x": 0, "y": 0, "z": 0 },
-            "size": { "width": 128.0, "height": 86, "depth": 0 },
-            "content_type": [
-              "plate",
-              "tip_rack",
-              "plates",
-              "tip_racks",
-              "tube_rack"
-            ]
-          }
-        ]
-      },
-      "data": {}
-    },
-    {
-      "id": "T2",
-      "name": "T2",
-      "children": [],
-      "parent": "PRCXI_Deck",
-      "type": "plate",
-      "class": "",
-      "position": {
-        "x": 138,
-        "y": 288,
-        "z": 0
-      },
-      "config": {
-        "type": "PRCXI9300Container",
-        "size_x": 127,
-        "size_y": 85.5,
-        "size_z": 10,
-        "rotation": {
-          "x": 0,
-          "y": 0,
-          "z": 0,
-          "type": "Rotation"
-        },
-        "category": "plate",
-        "model": null,
-        "barcode": null,
-        "ordering": {},
-        "sites": [
-          {
-            "label": "T2",
-            "visible": true,
-            "position": { "x": 0, "y": 0, "z": 0 },
-            "size": { "width": 128.0, "height": 86, "depth": 0 },
-            "content_type": [
-              "plate",
-              "tip_rack",
-              "plates",
-              "tip_racks",
-              "tube_rack"
-            ]
-          }
-        ]
-      },
-      "data": {}
-    },
-    {
-      "id": "T3",
-      "name": "T3",
-      "children": [],
-      "parent": "PRCXI_Deck",
-      "type": "plate",
-      "class": "",
-      "position": {
-        "x": 276,
-        "y": 288,
-        "z": 0
-      },
-      "config": {
-        "type": "PRCXI9300Container",
-        "size_x": 127,
-        "size_y": 85.5,
-        "size_z": 10,
-        "rotation": {
-          "x": 0,
-          "y": 0,
-          "z": 0,
-          "type": "Rotation"
-        },
-        "category": "plate",
-        "model": null,
-        "barcode": null,
-        "ordering": {},
-        "sites": [
-          {
-            "label": "T3",
-            "visible": true,
-            "position": { "x": 0, "y": 0, "z": 0 },
-            "size": { "width": 128.0, "height": 86, "depth": 0 },
-            "content_type": [
-              "plate",
-              "tip_rack",
-              "plates",
-              "tip_racks",
-              "tube_rack"
-            ]
-          }
-        ]
-      },
-      "data": {}
-    },
-    {
-      "id": "T4",
-      "name": "T4",
-      "children": [],
-      "parent": "PRCXI_Deck",
-      "type": "plate",
-      "class": "",
-      "position": {
-        "x": 414,
-        "y": 288,
-        "z": 0
-      },
-      "config": {
-        "type": "PRCXI9300Container",
-        "size_x": 127,
-        "size_y": 85.5,
-        "size_z": 10,
-        "rotation": {
-          "x": 0,
-          "y": 0,
-          "z": 0,
-          "type": "Rotation"
-        },
-        "category": "plate",
-        "model": null,
-        "barcode": null,
-        "ordering": {},
-        "sites": [
-          {
-            "label": "T4",
-            "visible": true,
-            "position": { "x": 0, "y": 0, "z": 0 },
-            "size": { "width": 128.0, "height": 86, "depth": 0 },
-            "content_type": [
-              "plate",
-              "tip_rack",
-              "plates",
-              "tip_racks",
-              "tube_rack"
-            ]
-          }
-        ]
-      },
-      "data": {}
-    },
-    {
-      "id": "T5",
-      "name": "T5",
-      "children": [],
-      "parent": "PRCXI_Deck",
-      "type": "plate",
-      "class": "",
-      "position": {
-        "x": 0,
-        "y": 192,
-        "z": 0
-      },
-      "config": {
-        "type": "PRCXI9300Container",
-        "size_x": 127,
-        "size_y": 85.5,
-        "size_z": 10,
-        "rotation": {
-          "x": 0,
-          "y": 0,
-          "z": 0,
-          "type": "Rotation"
-        },
-        "category": "plate",
-        "model": null,
-        "barcode": null,
-        "ordering": {},
-        "sites": [
-          {
-            "label": "T5",
-            "visible": true,
-            "position": { "x": 0, "y": 0, "z": 0 },
-            "size": { "width": 128.0, "height": 86, "depth": 0 },
-            "content_type": [
-              "plate",
-              "tip_rack",
-              "plates",
-              "tip_racks",
-              "tube_rack"
-            ]
-          }
-        ]
-      },
-      "data": {}
-    },
-    {
-      "id": "T6",
-      "name": "T6",
-      "children": [],
-      "parent": "PRCXI_Deck",
-      "type": "plate",
-      "class": "",
-      "position": {
-        "x": 138,
-        "y": 192,
-        "z": 0
-      },
-      "config": {
-        "type": "PRCXI9300Container",
-        "size_x": 127,
-        "size_y": 85.5,
-        "size_z": 10,
-        "rotation": {
-          "x": 0,
-          "y": 0,
-          "z": 0,
-          "type": "Rotation"
-        },
-        "category": "plate",
-        "model": null,
-        "barcode": null,
-        "ordering": {},
-        "sites": [
-          {
-            "label": "T6",
-            "visible": true,
-            "position": { "x": 0, "y": 0, "z": 0 },
-            "size": { "width": 128.0, "height": 86, "depth": 0 },
-            "content_type": [
-              "plate",
-              "tip_rack",
-              "plates",
-              "tip_racks",
-              "tube_rack"
-            ]
-          }
-        ]
-      },
-      "data": {}
-    },
-    {
-      "id": "T7",
-      "name": "T7",
-      "children": [],
-      "parent": "PRCXI_Deck",
-      "type": "plate",
-      "class": "",
-      "position": {
-        "x": 276,
-        "y": 192,
-        "z": 0
-      },
-      "config": {
-        "type": "PRCXI9300Container",
-        "size_x": 127,
-        "size_y": 85.5,
-        "size_z": 10,
-        "rotation": {
-          "x": 0,
-          "y": 0,
-          "z": 0,
-          "type": "Rotation"
-        },
-        "category": "plate",
-        "model": null,
-        "barcode": null,
-        "ordering": {},
-        "sites": [
-          {
-            "label": "T7",
-            "visible": true,
-            "position": { "x": 0, "y": 0, "z": 0 },
-            "size": { "width": 128.0, "height": 86, "depth": 0 },
-            "content_type": [
-              "plate",
-              "tip_rack",
-              "plates",
-              "tip_racks",
-              "tube_rack"
-            ]
-          }
-        ]
-      },
-      "data": {}
-    },
-    {
-      "id": "T8",
-      "name": "T8",
-      "children": [],
-      "parent": "PRCXI_Deck",
-      "type": "plate",
-      "class": "",
-      "position": {
-        "x": 414,
-        "y": 192,
-        "z": 0
-      },
-      "config": {
-        "type": "PRCXI9300Container",
-        "size_x": 127,
-        "size_y": 85.5,
-        "size_z": 10,
-        "rotation": {
-          "x": 0,
-          "y": 0,
-          "z": 0,
-          "type": "Rotation"
-        },
-        "category": "plate",
-        "model": null,
-        "barcode": null,
-        "ordering": {},
-        "sites": [
-          {
-            "label": "T8",
-            "visible": true,
-            "position": { "x": 0, "y": 0, "z": 0 },
-            "size": { "width": 128.0, "height": 86, "depth": 0 },
-            "content_type": [
-              "plate",
-              "tip_rack",
-              "plates",
-              "tip_racks",
-              "tube_rack"
-            ]
-          }
-        ]
-      },
-      "data": {}
-    },
-    {
-      "id": "T9",
-      "name": "T9",
-      "children": [],
-      "parent": "PRCXI_Deck",
-      "type": "plate",
-      "class": "",
-      "position": {
-        "x": 0,
-        "y": 96,
-        "z": 0
-      },
-      "config": {
-        "type": "PRCXI9300Container",
-        "size_x": 127,
-        "size_y": 85.5,
-        "size_z": 10,
-        "rotation": {
-          "x": 0,
-          "y": 0,
-          "z": 0,
-          "type": "Rotation"
-        },
-        "category": "plate",
-        "model": null,
-        "barcode": null,
-        "ordering": {},
-        "sites": [
-          {
-            "label": "T9",
-            "visible": true,
-            "position": { "x": 0, "y": 0, "z": 0 },
-            "size": { "width": 128.0, "height": 86, "depth": 0 },
-            "content_type": [
-              "plate",
-              "tip_rack",
-              "plates",
-              "tip_racks",
-              "tube_rack"
-            ]
-          }
-        ]
-      },
-      "data": {}
-    },
-    {
-      "id": "T10",
-      "name": "T10",
-      "children": [],
-      "parent": "PRCXI_Deck",
-      "type": "plate",
-      "class": "",
-      "position": {
-        "x": 138,
-        "y": 96,
-        "z": 0
-      },
-      "config": {
-        "type": "PRCXI9300Container",
-        "size_x": 127,
-        "size_y": 85.5,
-        "size_z": 10,
-        "rotation": {
-          "x": 0,
-          "y": 0,
-          "z": 0,
-          "type": "Rotation"
-        },
-        "category": "plate",
-        "model": null,
-        "barcode": null,
-        "ordering": {},
-        "sites": [
-          {
-            "label": "T10",
-            "visible": true,
-            "position": { "x": 0, "y": 0, "z": 0 },
-            "size": { "width": 128.0, "height": 86, "depth": 0 },
-            "content_type": [
-              "plate",
-              "tip_rack",
-              "plates",
-              "tip_racks",
-              "tube_rack"
-            ]
-          }
-        ]
-      },
-      "data": {}
-    },
-    {
-      "id": "T11",
-      "name": "T11",
-      "children": [],
-      "parent": "PRCXI_Deck",
-      "type": "plate",
-      "class": "",
-      "position": {
-        "x": 276,
-        "y": 96,
-        "z": 0
-      },
-      "config": {
-        "type": "PRCXI9300Container",
-        "size_x": 127,
-        "size_y": 85.5,
-        "size_z": 10,
-        "rotation": {
-          "x": 0,
-          "y": 0,
-          "z": 0,
-          "type": "Rotation"
-        },
-        "category": "plate",
-        "model": null,
-        "barcode": null,
-        "ordering": {},
-        "sites": [
-          {
-            "label": "T11",
-            "visible": true,
-            "position": { "x": 0, "y": 0, "z": 0 },
-            "size": { "width": 128.0, "height": 86, "depth": 0 },
-            "content_type": [
-              "plate",
-              "tip_rack",
-              "plates",
-              "tip_racks",
-              "tube_rack"
-            ]
-          }
-        ]
-      },
-      "data": {}
-    },
-    {
-      "id": "T12",
-      "name": "T12",
-      "children": [],
-      "parent": "PRCXI_Deck",
-      "type": "plate",
-      "class": "",
-      "position": {
-        "x": 414,
-        "y": 96,
-        "z": 0
-      },
-      "config": {
-        "type": "PRCXI9300Container",
-        "size_x": 127,
-        "size_y": 85.5,
-        "size_z": 10,
-        "rotation": {
-          "x": 0,
-          "y": 0,
-          "z": 0,
-          "type": "Rotation"
-        },
-        "category": "plate",
-        "model": null,
-        "barcode": null,
-        "ordering": {},
-        "sites": [
-          {
-            "label": "T12",
-            "visible": true,
-            "position": { "x": 0, "y": 0, "z": 0 },
-            "size": { "width": 128.0, "height": 86, "depth": 0 },
-            "content_type": [
-              "plate",
-              "tip_rack",
-              "plates",
-              "tip_racks",
-              "tube_rack"
-            ]
-          }
-        ]
-      },
-      "data": {}
-    },
-    {
-      "id": "T13",
-      "name": "T13",
-      "children": [],
-      "parent": "PRCXI_Deck",
-      "type": "plate",
-      "class": "",
-      "position": {
-        "x": 0,
-        "y": 0,
-        "z": 0
-      },
-      "config": {
-        "type": "PRCXI9300Container",
-        "size_x": 127,
-        "size_y": 85.5,
-        "size_z": 10,
-        "rotation": {
-          "x": 0,
-          "y": 0,
-          "z": 0,
-          "type": "Rotation"
-        },
-        "category": "plate",
-        "model": null,
-        "barcode": null,
-        "ordering": {},
-        "sites": [
-          {
-            "label": "T13",
-            "visible": true,
-            "position": { "x": 0, "y": 0, "z": 0 },
-            "size": { "width": 128.0, "height": 86, "depth": 0 },
-            "content_type": [
-              "plate",
-              "tip_rack",
-              "plates",
-              "tip_racks",
-              "tube_rack"
-            ]
-          }
-        ]
-      },
-      "data": {}
-    },
-    {
-      "id": "T14",
-      "name": "T14",
-      "children": [],
-      "parent": "PRCXI_Deck",
-      "type": "plate",
-      "class": "",
-      "position": {
-        "x": 138,
-        "y": 0,
-        "z": 0
-      },
-      "config": {
-        "type": "PRCXI9300Container",
-        "size_x": 127,
-        "size_y": 85.5,
-        "size_z": 10,
-        "rotation": {
-          "x": 0,
-          "y": 0,
-          "z": 0,
-          "type": "Rotation"
-        },
-        "category": "plate",
-        "model": null,
-        "barcode": null,
-        "ordering": {},
-        "sites": [
-          {
-            "label": "T14",
-            "visible": true,
-            "position": { "x": 0, "y": 0, "z": 0 },
-            "size": { "width": 128.0, "height": 86, "depth": 0 },
-            "content_type": [
-              "plate",
-              "tip_rack",
-              "plates",
-              "tip_racks",
-              "tube_rack"
-            ]
-          }
-        ]
-      },
-      "data": {}
-    },
-    {
-      "id": "T15",
-      "name": "T15",
-      "children": [],
-      "parent": "PRCXI_Deck",
-      "type": "plate",
-      "class": "",
-      "position": {
-        "x": 276,
-        "y": 0,
-        "z": 0
-      },
-      "config": {
-        "type": "PRCXI9300Container",
-        "size_x": 127,
-        "size_y": 85.5,
-        "size_z": 10,
-        "rotation": {
-          "x": 0,
-          "y": 0,
-          "z": 0,
-          "type": "Rotation"
-        },
-        "category": "plate",
-        "model": null,
-        "barcode": null,
-        "ordering": {},
-        "sites": [
-          {
-            "label": "T15",
-            "visible": true,
-            "position": { "x": 0, "y": 0, "z": 0 },
-            "size": { "width": 128.0, "height": 86, "depth": 0 },
-            "content_type": [
-              "plate",
-              "tip_rack",
-              "plates",
-              "tip_racks",
-              "tube_rack"
-            ]
-          }
-        ]
-      },
-      "data": {}
-    },
-    {
-      "id": "T16",
-      "name": "T16",
-      "children": [],
-      "parent": "PRCXI_Deck",
-      "type": "plate",
-      "class": "",
-      "position": {
-        "x": 414,
-        "y": 0,
-        "z": 0
-      },
-      "config": {
-        "type": "PRCXI9300Container",
-        "size_x": 127,
-        "size_y": 85.5,
-        "size_z": 10,
-        "rotation": {
-          "x": 0,
-          "y": 0,
-          "z": 0,
-          "type": "Rotation"
-        },
-        "category": "plate",
-        "model": null,
-        "barcode": null,
-        "ordering": {},
-        "sites": [
-          {
-            "label": "T16",
-            "visible": true,
-            "position": { "x": 0, "y": 0, "z": 0 },
-            "size": { "width": 128.0, "height": 86, "depth": 0 },
-            "content_type": [
-              "plate",
-              "tip_rack",
-              "plates",
-              "tip_racks",
-              "tube_rack"
-            ]
-          }
-        ]
-      },
-      "data": {}
-    }
-  ],
-  "edges": []
-}

unilabos/utils/import_manager.py

@@ -27,7 +27,6 @@ __all__ = [
 
 from ast import Constant
 
-from unilabos.resources.resource_tracker import PARAM_SAMPLE_UUIDS
 from unilabos.utils import logger
 from unilabos.utils.decorator import is_not_action
 
@@ -342,18 +341,13 @@ class ImportManager:
                     result["action_methods"][method_name] = method_info
         return result
 
-    def _analyze_method_signature(self, method, skip_unilabos_params: bool = True) -> Dict[str, Any]:
+    def _analyze_method_signature(self, method) -> Dict[str, Any]:
         """
         分析方法签名，提取具体的命名参数信息
 
         注意：此方法会跳过*args和**kwargs，只提取具体的命名参数
         这样可以确保通过**dict方式传参时的准确性
 
-        Args:
-            method: 要分析的方法
-            skip_unilabos_params: 是否跳过 unilabos 系统参数（如 sample_uuids），
-                                  registry 补全时为 True，JsonCommand 执行时为 False
-
         示例用法：
             method_info = self._analyze_method_signature(some_method)
             params = {"param1": "value1", "param2": "value2"}
@@ -374,10 +368,6 @@ class ImportManager:
             if param.kind == param.VAR_KEYWORD:  # **kwargs
                 continue
 
-            # 跳过 sample_uuids 参数（由系统自动注入，registry 补全时跳过）
-            if skip_unilabos_params and param_name == PARAM_SAMPLE_UUIDS:
-                continue
-
             is_required = param.default == inspect.Parameter.empty
             if is_required:
                 num_required += 1
@@ -573,9 +563,6 @@ class ImportManager:
         for i, arg in enumerate(node.args.args):
             if arg.arg == "self":
                 continue
-            # 跳过 sample_uuids 参数（由系统自动注入）
-            if arg.arg == PARAM_SAMPLE_UUIDS:
-                continue
             arg_info = {
                 "name": arg.arg,
                 "type": None,

unilabos/workflow/common.py

@@ -19,9 +19,7 @@
 
 第一步: 按 slot 去重创建 create_resource 节点（创建板子）
 --------------------------------------------------------------------------------
-- 首先创建一个 Group 节点（type="Group", minimized=true），用于包含所有 create_resource 节点
 - 遍历所有 reagent，按 slot 去重，为每个唯一的 slot 创建一个板子
-- 所有 create_resource 节点的 parent_uuid 指向 Group 节点，minimized=true
 - 生成参数:
     res_id: plate_slot_{slot}
     device_id: /PRCXI
@@ -31,13 +29,11 @@
 - 输出端口: labware（用于连接 set_liquid_from_plate）
 - 控制流: create_resource 之间通过 ready 端口串联
 
-示例: slot=1, slot=4 -> 创建 1 个 Group + 2 个 create_resource 节点
+示例: slot=1, slot=4 -> 创建 2 个 create_resource 节点
 
 第二步: 为每个 reagent 创建 set_liquid_from_plate 节点（设置液体）
 --------------------------------------------------------------------------------
-- 首先创建一个 Group 节点（type="Group", minimized=true），用于包含所有 set_liquid_from_plate 节点
 - 遍历所有 reagent，为每个试剂创建 set_liquid_from_plate 节点
-- 所有 set_liquid_from_plate 节点的 parent_uuid 指向 Group 节点，minimized=true
 - 生成参数:
     plate: []（通过连接传递，来自 create_resource 的 labware）
     well_names: ["A1", "A3", "A5"]（来自 reagent 的 well 数组）
@@ -60,11 +56,7 @@
 ==================== 连接关系图 ====================
 
 控制流 (ready 端口串联):
-    - create_resource 之间: 无 ready 连接
+    create_resource_1 -> create_resource_2 -> ... -> set_liquid_1 -> set_liquid_2 -> ... -> transfer_liquid_1 -> transfer_liquid_2 -> ...
-    - set_liquid_from_plate 之间: 无 ready 连接
-    - create_resource 与 set_liquid_from_plate 之间: 无 ready 连接
-    - transfer_liquid 之间: 通过 ready 端口串联
-        transfer_liquid_1 -> transfer_liquid_2 -> transfer_liquid_3 -> ...
 
 物料流:
     [create_resource] --labware--> [set_liquid_from_plate] --output_wells--> [transfer_liquid] --sources_out/targets_out--> [下一个 transfer_liquid]
@@ -84,13 +76,6 @@ transfer_liquid:
     输入: sources -> sources_identifier, targets -> targets_identifier
     输出: sources -> sources_out, targets -> targets_out
 
-==================== 设备名配置 (device_name) ====================
-
-每个节点都有 device_name 字段，指定在哪个设备上执行:
-- create_resource: device_name = "host_node"（固定）
-- set_liquid_from_plate: device_name = "PRCXI"（可配置，见 DEVICE_NAME_DEFAULT）
-- transfer_liquid 等动作: device_name = "PRCXI"（可配置，见 DEVICE_NAME_DEFAULT）
-
 ==================== 校验规则 ====================
 
 - 检查 sources/targets 是否在 reagent 中定义
@@ -112,13 +97,6 @@ Json = Dict[str, Any]
 
 # ==================== 默认配置 ====================
 
-# 设备名配置
-DEVICE_NAME_HOST = "host_node"  # create_resource 固定在 host_node 上执行
-DEVICE_NAME_DEFAULT = "PRCXI"  # transfer_liquid, set_liquid_from_plate 等动作的默认设备名
-
-# 节点类型
-NODE_TYPE_DEFAULT = "ILab"  # 所有节点的默认类型
-
 # create_resource 节点默认参数
 CREATE_RESOURCE_DEFAULTS = {
     "device_id": "/PRCXI",
@@ -389,23 +367,9 @@ def build_protocol_graph(
                 "res_id": res_id,
             }
 
-    # 创建 Group 节点，包含所有 create_resource 节点
-    group_node_id = str(uuid.uuid4())
-    G.add_node(
-        group_node_id,
-        name="Resources Group",
-        type="Group",
-        parent_uuid="",
-        lab_node_type="Device",
-        template_name="",
-        resource_name="",
-        footer="",
-        minimized=True,
-        param=None,
-    )
-
     # 为每个唯一的 slot 创建 create_resource 节点
     res_index = 0
+    last_create_resource_id = None
     for slot, info in slots_info.items():
         node_id = str(uuid.uuid4())
         res_id = info["res_id"]
@@ -419,10 +383,6 @@ def build_protocol_graph(
             description=f"Create plate on slot {slot}",
             lab_node_type="Labware",
             footer="create_resource-host_node",
-            device_name=DEVICE_NAME_HOST,
-            type=NODE_TYPE_DEFAULT,
-            parent_uuid=group_node_id,  # 指向 Group 节点
-            minimized=True,  # 折叠显示
             param={
                 "res_id": res_id,
                 "device_id": CREATE_RESOURCE_DEFAULTS["device_id"],
@@ -434,25 +394,14 @@ def build_protocol_graph(
         )
         slot_to_create_resource[slot] = node_id
 
-        # create_resource 之间不需要 ready 连接
+        # create_resource 之间通过 ready 串联
+        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 节点 ====================
-    # 创建 Group 节点，包含所有 set_liquid_from_plate 节点
-    set_liquid_group_id = str(uuid.uuid4())
-    G.add_node(
-        set_liquid_group_id,
-        name="SetLiquid Group",
-        type="Group",
-        parent_uuid="",
-        lab_node_type="Device",
-        template_name="",
-        resource_name="",
-        footer="",
-        minimized=True,
-        param=None,
-    )
-
     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 类型
@@ -481,10 +430,6 @@ def build_protocol_graph(
             description=f"Set liquid: {labware_id}",
             lab_node_type="Reagent",
             footer="set_liquid_from_plate-liquid_handler.prcxi",
-            device_name=DEVICE_NAME_DEFAULT,
-            type=NODE_TYPE_DEFAULT,
-            parent_uuid=set_liquid_group_id,  # 指向 Group 节点
-            minimized=True,  # 折叠显示
             param={
                 "plate": [],  # 通过连接传递
                 "well_names": wells,  # 孔位名数组，如 ["A1", "A3", "A5"]
@@ -493,7 +438,10 @@ def build_protocol_graph(
             },
         )
 
-        # set_liquid_from_plate 之间不需要 ready 连接
+        # 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)
@@ -503,8 +451,7 @@ def build_protocol_graph(
         # set_liquid_from_plate 的输出 output_wells 用于连接 transfer_liquid
         resource_last_writer[labware_id] = f"{node_id}:output_wells"
 
-    # transfer_liquid 之间通过 ready 串联，从 None 开始
+    last_control_node_id = last_set_liquid_id
-    last_control_node_id = None
 
     # 端口名称映射：JSON 字段名 -> 实际 handle key
     INPUT_PORT_MAPPING = {
@@ -597,11 +544,9 @@ def build_protocol_graph(
             if param_key in params:
                 params[param_key] = []
 
-        # 更新 step 的 param、footer、device_name 和 type
+        # 更新 step 的 param 和 footer
         step_copy = step.copy()
         step_copy["param"] = params
-        step_copy["device_name"] = DEVICE_NAME_DEFAULT  # 动作节点使用默认设备名
-        step_copy["type"] = NODE_TYPE_DEFAULT  # 节点类型
 
         # 如果有警告，修改 footer 添加警告标记（警告放前面）
         if warnings:

unilabos/workflow/from_python_script.py

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

unilabos/workflow/from_xdl.py

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