Uni-Lab-OS/unilabos/compile/pump_protocol.py

import traceback
import numpy as np
import networkx as nx
import asyncio
import time as time_module  # 重命名time模块
from typing import List, Dict, Any
import logging
import sys

from .utils.logger_util import debug_print
from .utils.vessel_parser import get_vessel
from .utils.resource_helper import get_resource_liquid_volume

logger = logging.getLogger(__name__)


def is_integrated_pump(node_class: str, node_name: str = "") -> bool:
    """
    判断是否为泵阀一体设备
    """
    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):
    """
    查找与阀门相连的泵节点 - 修复版本
    🔧 修复：区分电磁阀和多通阀，电磁阀不参与泵查找
    """
    debug_print(f"🔍 查找与阀门 {valve_node} 相连的泵...")

    # 🔧 关键修复：检查节点类型，电磁阀不应该查找泵
    node_data = G.nodes.get(valve_node, {})
    node_class = node_data.get("class", "") or ""

    debug_print(f"  - 阀门类型: {node_class}")

    # 如果是电磁阀，不应该查找泵（电磁阀只是开关）
    if ("solenoid" in node_class.lower() or "solenoid_valve" in valve_node.lower()):
        debug_print(f"  ⚠️ {valve_node} 是电磁阀，不应该查找泵节点")
        raise ValueError(f"电磁阀 {valve_node} 不应该参与泵查找逻辑")

    # 只有多通阀等复杂阀门才需要查找连接的泵
    if ("multiway" in node_class.lower() or "valve" in node_class.lower()):
        debug_print(f"  - {valve_node} 是多通阀，查找连接的泵...")
        # 方法1：直接相邻的泵
        for neighbor in G.neighbors(valve_node):
            neighbor_class = G.nodes[neighbor].get("class", "") or ""
            # 排除非 电磁阀 和 泵 的邻居
            debug_print(f"    - 检查邻居 {neighbor}, class: {neighbor_class}")
            if "pump" in neighbor_class.lower():
                debug_print(f"    ✅ 找到直接相连的泵: {neighbor}")
                return neighbor

        # 方法2：通过路径查找泵（最多2跳）
        debug_print(f"    - 未找到直接相连的泵，尝试路径查找...")

        # 获取所有泵节点
        pump_nodes = []
        for node_id in G.nodes():
            node_class = G.nodes[node_id].get("class", "") or ""
            if "pump" in node_class.lower():
                pump_nodes.append(node_id)

        debug_print(f"    - 系统中的泵节点: {pump_nodes}")

        # 查找到泵的最短路径
        for pump_node in pump_nodes:
            try:
                if nx.has_path(G, valve_node, pump_node):
                    path = nx.shortest_path(G, valve_node, pump_node)
                    path_length = len(path) - 1
                    debug_print(f"    - 到泵 {pump_node} 的路径: {path}, 距离: {path_length}")

                    if path_length <= 2:  # 最多允许2跳
                        debug_print(f"    ✅ 通过路径找到泵: {pump_node}")
                        return pump_node
            except nx.NetworkXNoPath:
                continue

    # 最终失败
    debug_print(f"  ❌ 完全找不到泵节点")
    raise ValueError(f"未找到与阀 {valve_node} 相连的泵节点")


def build_pump_valve_maps(G, pump_backbone):
    """
    构建泵-阀门映射 - 修复版本
    🔧 修复：过滤掉电磁阀，只处理需要泵的多通阀
    """
    pumps_from_node = {}
    valve_from_node = {}

    debug_print(f"🔧 构建泵-阀门映射，原始骨架: {pump_backbone}")

    # 🔧 关键修复：过滤掉电磁阀
    filtered_backbone = []
    for node in pump_backbone:
        node_data = G.nodes.get(node, {})
        node_class = node_data.get("class", "") or ""

        # 跳过电磁阀
        if ("solenoid" in node_class.lower() or "solenoid_valve" in node.lower()):
            debug_print(f"  - 跳过电磁阀: {node}")
            continue

        filtered_backbone.append(node)

    debug_print(f"🔧 过滤后的骨架: {filtered_backbone}")

    for node in filtered_backbone:
        node_data = G.nodes.get(node, {})
        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}")
        else:
            try:
                pump_node = find_connected_pump(G, node)
                pumps_from_node[node] = pump_node
                valve_from_node[node] = node
                debug_print(f"  - 阀门 {node} -> 泵 {pump_node}")
            except ValueError as e:
                debug_print(f"  - 跳过节点 {node}: {str(e)}")
                continue

    debug_print(f"🔧 最终映射: pumps={pumps_from_node}, valves={valve_from_node}")
    return pumps_from_node, valve_from_node


def generate_pump_protocol(
        G: nx.DiGraph,
        from_vessel_id: str,
        to_vessel_id: str,
        volume: float,
        flowrate: float = 2.5,
        transfer_flowrate: float = 0.5,
) -> List[Dict[str, Any]]:
    """
    生成泵操作的动作序列 - 修复版本
    🔧 修复：正确处理包含电磁阀的路径
    """
    pump_action_sequence = []
    nodes = G.nodes(data=True)

    # 验证输入参数
    if volume <= 0:
        logger.error(f"无效的体积参数: {volume}mL")
        return pump_action_sequence

    if flowrate <= 0:
        flowrate = 2.5
        logger.warning(f"flowrate <= 0，使用默认值 {flowrate}mL/s")

    if transfer_flowrate <= 0:
        transfer_flowrate = 0.5
        logger.warning(f"transfer_flowrate <= 0，使用默认值 {transfer_flowrate}mL/s")

    # 验证容器存在
    debug_print(f"🔍 验证源容器 '{from_vessel_id}' 和目标容器 '{to_vessel_id}' 是否存在...")
    if from_vessel_id not in G.nodes():
        logger.error(f"源容器 '{from_vessel_id}' 不存在")
        return pump_action_sequence

    if to_vessel_id not in G.nodes():
        logger.error(f"目标容器 '{to_vessel_id}' 不存在")
        return pump_action_sequence

    try:
        shortest_path = nx.shortest_path(G, source=from_vessel_id, target=to_vessel_id)
        debug_print(f"PUMP_TRANSFER: 路径 {from_vessel_id} -> {to_vessel_id}: {shortest_path}")
    except nx.NetworkXNoPath:
        logger.error(f"无法找到从 '{from_vessel_id}' 到 '{to_vessel_id}' 的路径")
        return pump_action_sequence

    # 🔧 关键修复：正确构建泵骨架，排除容器和电磁阀
    pump_backbone = []
    for node in shortest_path:
        # 跳过起始和结束容器
        if node == from_vessel_id or node == to_vessel_id:
            continue

        # 跳过电磁阀（电磁阀不参与泵操作）
        node_data = G.nodes.get(node, {})
        node_class = node_data.get("class", "") or ""
        if ("solenoid" in node_class.lower() or "solenoid_valve" in node.lower()):
            debug_print(f"PUMP_TRANSFER: 跳过电磁阀 {node}")
            continue

        # 只包含多通阀和泵
        if ("multiway" in node_class.lower() or "valve" in node_class.lower() or "pump" in node_class.lower()):
            pump_backbone.append(node)

    debug_print(f"PUMP_TRANSFER: 过滤后的泵骨架: {pump_backbone}")

    if not pump_backbone:
        debug_print("PUMP_TRANSFER: 没有泵骨架节点，可能是直接容器连接或只有电磁阀")
        return pump_action_sequence

    if transfer_flowrate == 0:
        transfer_flowrate = flowrate

    try:
        pumps_from_node, valve_from_node = build_pump_valve_maps(G, pump_backbone)
    except Exception as e:
        debug_print(f"PUMP_TRANSFER: 构建泵-阀门映射失败: {str(e)}")
        return pump_action_sequence

    if not pumps_from_node:
        debug_print("PUMP_TRANSFER: 没有可用的泵映射")
        return pump_action_sequence

    # 🔧 修复：安全地获取最小转移体积
    try:
        min_transfer_volumes = []
        for node in pump_backbone:
            if node in pumps_from_node:
                pump_node = pumps_from_node[node]
                if pump_node in nodes:
                    pump_config = nodes[pump_node].get("config", {})
                    max_volume = pump_config.get("max_volume")
                    if max_volume is not None:
                        min_transfer_volumes.append(max_volume)

        if min_transfer_volumes:
            min_transfer_volume = min(min_transfer_volumes)
        else:
            min_transfer_volume = 25.0  # 默认值
            debug_print(f"PUMP_TRANSFER: 无法获取泵的最大体积，使用默认值: {min_transfer_volume}mL")
    except Exception as e:
        debug_print(f"PUMP_TRANSFER: 获取最小转移体积失败: {str(e)}")
        min_transfer_volume = 25.0  # 默认值

    repeats = int(np.ceil(volume / min_transfer_volume))

    if repeats > 1 and (from_vessel_id.startswith("pump") or to_vessel_id.startswith("pump")):
        logger.error("Cannot transfer volume larger than min_transfer_volume between two pumps.")
        return pump_action_sequence

    volume_left = volume
    debug_print(f"PUMP_TRANSFER: 需要 {repeats} 次转移，单次最大体积 {min_transfer_volume} mL")

    # 🆕 只在开头打印总体概览
    if repeats > 1:
        debug_print(f"🔄 分批转移概览: 总体积 {volume:.2f}mL，需要 {repeats} 次转移")
        logger.info(f"🔄 分批转移概览: 总体积 {volume:.2f}mL，需要 {repeats} 次转移")

    # 🔧 创建一个自定义的wait动作，用于在执行时打印日志
    def create_progress_log_action(message: str) -> Dict[str, Any]:
        """创建一个特殊的等待动作，在执行时打印进度日志"""
        return {
            "action_name": "wait",
            "action_kwargs": {
                "time": 0.1,  # 很短的等待时间
                "progress_message": message  # 自定义字段，用于进度日志
            }
        }

    # 生成泵操作序列
    for i in range(repeats):
        current_volume = min(volume_left, min_transfer_volume)

        # 🆕 在每次循环开始时添加进度日志
        if repeats > 1:
            start_message = f"🚀 准备开始第 {i + 1}/{repeats} 次转移: {current_volume:.2f}mL ({from_vessel_id} → {to_vessel_id}) 🚰"
            pump_action_sequence.append(create_progress_log_action(start_message))

        # 🔧 修复：安全地获取边数据
        def get_safe_edge_data(node_a, node_b, key):
            try:
                edge_data = G.get_edge_data(node_a, node_b)
                if edge_data and "port" in edge_data:
                    port_data = edge_data["port"]
                    if isinstance(port_data, dict) and key in port_data:
                        return port_data[key]
                return "default"
            except Exception as e:
                debug_print(f"PUMP_TRANSFER: 获取边数据失败 {node_a}->{node_b}: {str(e)}")
                return "default"

        # 从源容器吸液
        if not from_vessel_id.startswith("pump") and pump_backbone:
            first_pump_node = pump_backbone[0]
            if first_pump_node in valve_from_node and first_pump_node in pumps_from_node:
                port_command = get_safe_edge_data(first_pump_node, from_vessel_id, first_pump_node)
                pump_action_sequence.extend([
                    {
                        "device_id": valve_from_node[first_pump_node],
                        "action_name": "set_valve_position",
                        "action_kwargs": {
                            "command": port_command
                        }
                    },
                    {
                        "device_id": pumps_from_node[first_pump_node],
                        "action_name": "set_position",
                        "action_kwargs": {
                            "position": float(current_volume),
                            "max_velocity": transfer_flowrate
                        }
                    }
                ])
                pump_action_sequence.append({"action_name": "wait", "action_kwargs": {"time": 3}})

        # 泵间转移
        for nodeA, nodeB in zip(pump_backbone[:-1], pump_backbone[1:]):
            if nodeA in valve_from_node and nodeB in valve_from_node and nodeA in pumps_from_node and nodeB in pumps_from_node:
                port_a = get_safe_edge_data(nodeA, nodeB, nodeA)
                port_b = get_safe_edge_data(nodeB, nodeA, nodeB)

                pump_action_sequence.append([
                    {
                        "device_id": valve_from_node[nodeA],
                        "action_name": "set_valve_position",
                        "action_kwargs": {
                            "command": port_a
                        }
                    },
                    {
                        "device_id": valve_from_node[nodeB],
                        "action_name": "set_valve_position",
                        "action_kwargs": {
                            "command": port_b
                        }
                    }
                ])
                pump_action_sequence.append([
                    {
                        "device_id": pumps_from_node[nodeA],
                        "action_name": "set_position",
                        "action_kwargs": {
                            "position": 0.0,
                            "max_velocity": transfer_flowrate
                        }
                    },
                    {
                        "device_id": pumps_from_node[nodeB],
                        "action_name": "set_position",
                        "action_kwargs": {
                            "position": float(current_volume),
                            "max_velocity": transfer_flowrate
                        }
                    }
                ])
                pump_action_sequence.append({"action_name": "wait", "action_kwargs": {"time": 3}})

        # 排液到目标容器
        if not to_vessel_id.startswith("pump") and pump_backbone:
            last_pump_node = pump_backbone[-1]
            if last_pump_node in valve_from_node and last_pump_node in pumps_from_node:
                port_command = get_safe_edge_data(last_pump_node, to_vessel_id, last_pump_node)
                pump_action_sequence.extend([
                    {
                        "device_id": valve_from_node[last_pump_node],
                        "action_name": "set_valve_position",
                        "action_kwargs": {
                            "command": port_command
                        }
                    },
                    {
                        "device_id": pumps_from_node[last_pump_node],
                        "action_name": "set_position",
                        "action_kwargs": {
                            "position": 0.0,
                            "max_velocity": flowrate
                        }
                    }
                ])
                pump_action_sequence.append({"action_name": "wait", "action_kwargs": {"time": 3}})

        # 🆕 在每次循环结束时添加完成日志
        if repeats > 1:
            remaining_volume = volume_left - current_volume
            if remaining_volume > 0:
                end_message = f"✅ 第 {i + 1}/{repeats} 次转移完成! 剩余 {remaining_volume:.2f}mL 待转移 ⏳"
            else:
                end_message = f"🎉 第 {i + 1}/{repeats} 次转移完成! 全部 {volume:.2f}mL 转移完毕 ✨"

            pump_action_sequence.append(create_progress_log_action(end_message))

        volume_left -= current_volume

    return pump_action_sequence


# 保持原有的同步版本兼容性
def generate_pump_protocol_with_rinsing(
        G: nx.DiGraph,
        from_vessel: dict,
        to_vessel: dict,
        volume: float = 0.0,
        amount: str = "",
        time: float = 0.0,
        viscous: bool = False,
        rinsing_solvent: str = "",
        rinsing_volume: float = 0.0,
        rinsing_repeats: int = 0,
        solid: bool = False,
        flowrate: float = 2.5,
        transfer_flowrate: float = 0.5,
        rate_spec: str = "",
        event: str = "",
        through: str = "",
        **kwargs
) -> List[Dict[str, Any]]:
    """
    原有的同步版本，添加防冲突机制
    """

    # 添加执行锁，防止并发调用
    import threading
    if not hasattr(generate_pump_protocol_with_rinsing, '_lock'):
        generate_pump_protocol_with_rinsing._lock = threading.Lock()

    from_vessel_id, _ = get_vessel(from_vessel)
    to_vessel_id, _ = get_vessel(to_vessel)

    with generate_pump_protocol_with_rinsing._lock:
        debug_print(f"PUMP_TRANSFER: {from_vessel_id} -> {to_vessel_id}, volume={volume}, flowrate={flowrate}")

        # 短暂延迟，避免快速重复调用
        time_module.sleep(0.01)

        # 1. 处理体积参数
        final_volume = volume
        debug_print(f"初始体积: {final_volume}")

        # 如果volume为0，从容器读取实际体积
        if volume == 0.0:

            actual_volume = get_resource_liquid_volume(G.nodes.get(from_vessel_id, {}))

            if actual_volume > 0:
                final_volume = actual_volume
                debug_print(f"从容器读取体积: {final_volume}mL")
            else:
                final_volume = 10.0
                logger.warning(f"无法从容器读取体积，使用默认值: {final_volume}mL")
        else:
            debug_print(f"使用指定体积: {final_volume}mL")

        # 处理 amount 参数
        if amount and amount.strip():
            parsed_volume = _parse_amount_to_volume(amount)

            if parsed_volume > 0:
                final_volume = parsed_volume
            elif parsed_volume == 0.0 and amount.lower().strip() == "all":
                actual_volume = get_resource_liquid_volume(G.nodes.get(from_vessel_id, {}))
                if actual_volume > 0:
                    final_volume = actual_volume

        # 最终体积验证
        if final_volume <= 0:
            logger.error(f"体积无效: {final_volume}mL")
            final_volume = 10.0
            logger.warning(f"强制设置为默认值: {final_volume}mL")

        debug_print(f"最终体积: {final_volume}mL")

        # 2. 处理流速参数

        final_flowrate = flowrate if flowrate > 0 else 2.5
        final_transfer_flowrate = transfer_flowrate if transfer_flowrate > 0 else 0.5

        if flowrate <= 0:
            logger.warning(f"flowrate <= 0，修正为: {final_flowrate}mL/s")
        if transfer_flowrate <= 0:
            logger.warning(f"transfer_flowrate <= 0，修正为: {final_transfer_flowrate}mL/s")

        # 3. 根据时间计算流速
        if time > 0 and final_volume > 0:
            calculated_flowrate = final_volume / time

            if flowrate <= 0 or flowrate == 2.5:
                final_flowrate = min(calculated_flowrate, 10.0)
            if transfer_flowrate <= 0 or transfer_flowrate == 0.5:
                final_transfer_flowrate = min(calculated_flowrate, 5.0)

        # 4. 根据速度规格调整
        if rate_spec:
            if rate_spec == "dropwise":
                final_flowrate = min(final_flowrate, 0.1)
                final_transfer_flowrate = min(final_transfer_flowrate, 0.1)
            elif rate_spec == "slowly":
                final_flowrate = min(final_flowrate, 0.5)
                final_transfer_flowrate = min(final_transfer_flowrate, 0.3)
            elif rate_spec == "quickly":
                final_flowrate = max(final_flowrate, 5.0)
                final_transfer_flowrate = max(final_transfer_flowrate, 2.0)
            debug_print(f"速度规格 '{rate_spec}' 应用后: flowrate={final_flowrate}, transfer={final_transfer_flowrate}")

    # 5. 处理冲洗参数
    final_rinsing_solvent = rinsing_solvent
    final_rinsing_volume = rinsing_volume if rinsing_volume > 0 else 5.0
    final_rinsing_repeats = rinsing_repeats if rinsing_repeats > 0 else 2

    if rinsing_volume <= 0:
        logger.warning(f"rinsing_volume <= 0，修正为: {final_rinsing_volume}mL")
    if rinsing_repeats <= 0:
        logger.warning(f"rinsing_repeats <= 0，修正为: {final_rinsing_repeats}次")

    # 根据物理属性调整冲洗参数
    if viscous or solid:
        final_rinsing_repeats = max(final_rinsing_repeats, 3)
        final_rinsing_volume = max(final_rinsing_volume, 10.0)

    # 参数总结
    debug_print(f"最终参数: volume={final_volume}mL, flowrate={final_flowrate}mL/s, "
                f"transfer_flowrate={final_transfer_flowrate}mL/s, "
                f"rinsing={final_rinsing_solvent}/{final_rinsing_volume}mL/{final_rinsing_repeats}次")

    # ========== 执行基础转移 ==========
    try:

        pump_action_sequence = generate_pump_protocol(
            G, from_vessel_id, to_vessel_id, final_volume,
            final_flowrate, final_transfer_flowrate
        )

        debug_print(f"基础转移生成了 {len(pump_action_sequence)} 个动作")

        if not pump_action_sequence:
            debug_print("基础转移协议生成为空，可能是路径问题")

            if from_vessel_id in G.nodes() and to_vessel_id in G.nodes():
                try:
                    path = nx.shortest_path(G, source=from_vessel_id, target=to_vessel_id)
                    debug_print(f"路径存在: {path}")
                except Exception as path_error:
                    debug_print(f"无法找到路径: {str(path_error)}")

            return [
                {
                    "device_id": "system",
                    "action_name": "log_message",
                    "action_kwargs": {
                        "message": f"路径问题，无法转移: {final_volume}mL 从 {from_vessel_id} 到 {to_vessel_id}"
                    }
                }
            ]

    except Exception as e:
        debug_print(f"基础转移失败: {str(e)}")
        import traceback
        debug_print(f"详细错误: {traceback.format_exc()}")
        return [
            {
                "device_id": "system",
                "action_name": "log_message",
                "action_kwargs": {
                    "message": f"转移失败: {final_volume}mL 从 {from_vessel_id} 到 {to_vessel_id}, 错误: {str(e)}"
                }
            }
        ]

    # ========== 执行冲洗操作 ==========
    if final_rinsing_solvent and final_rinsing_solvent.strip() and final_rinsing_repeats > 0:
        debug_print(f"开始冲洗操作，溶剂: '{final_rinsing_solvent}'")

        try:
            if final_rinsing_solvent.strip() != "air":
                rinsing_actions = _generate_rinsing_sequence(
                    G, from_vessel_id, to_vessel_id, final_rinsing_solvent,
                    final_rinsing_volume, final_rinsing_repeats,
                    final_flowrate, final_transfer_flowrate
                )
                pump_action_sequence.extend(rinsing_actions)
            else:
                air_rinsing_actions = _generate_air_rinsing_sequence(
                    G, from_vessel_id, to_vessel_id, final_rinsing_volume, final_rinsing_repeats,
                    final_flowrate, final_transfer_flowrate
                )
                pump_action_sequence.extend(air_rinsing_actions)
        except Exception as e:
            debug_print(f"冲洗操作失败: {str(e)}，跳过冲洗")
    else:
        debug_print(f"跳过冲洗操作 (solvent='{final_rinsing_solvent}', repeats={final_rinsing_repeats})")

    # ========== 最终结果 ==========
    debug_print(f"PUMP_TRANSFER 完成: {from_vessel_id} -> {to_vessel_id}, "
                f"volume={final_volume}mL, 动作数={len(pump_action_sequence)}")

    # 最终验证
    if len(pump_action_sequence) == 0:
        debug_print("协议生成结果为空！")
        return [
            {
                "device_id": "system",
                "action_name": "log_message",
                "action_kwargs": {
                    "message": "协议生成失败: 无法生成任何动作序列"
                }
            }
        ]

    return pump_action_sequence


def _parse_amount_to_volume(amount: str) -> float:
    """解析 amount 字符串为体积"""
    if not amount:
        return 0.0

    amount = amount.lower().strip()

    # 处理特殊关键词
    if amount == "all":
        return 0.0  # 返回0.0，让调用者处理

    # 提取数字
    import re
    numbers = re.findall(r'[\d.]+', amount)

    if numbers:
        volume = float(numbers[0])

        # 单位转换
        if 'ml' in amount or 'milliliter' in amount:
            return volume
        elif 'l' in amount and 'ml' not in amount:
            return volume * 1000
        elif 'μl' in amount or 'microliter' in amount:
            return volume / 1000
        else:
            return volume  # 默认mL

    return 0.0


def _generate_rinsing_sequence(
    G: nx.DiGraph,
    from_vessel_id: str,
    to_vessel_id: str,
    rinsing_solvent: str,
    rinsing_volume: float,
    rinsing_repeats: int,
    flowrate: float,
    transfer_flowrate: float
) -> List[Dict[str, Any]]:
    """生成冲洗动作序列"""
    rinsing_actions = []

    try:
        shortest_path = nx.shortest_path(G, source=from_vessel_id, target=to_vessel_id)
        pump_backbone = shortest_path[1:-1]

        if not pump_backbone:
            return rinsing_actions

        nodes = G.nodes(data=True)
        pumps_from_node, valve_from_node = build_pump_valve_maps(G, pump_backbone)
        min_transfer_volume = min([nodes[pumps_from_node[node]]["config"]["max_volume"] for node in pump_backbone])

        waste_vessel = "waste_workup"

        # 处理多种溶剂情况
        if "," in rinsing_solvent:
            rinsing_solvents = rinsing_solvent.split(",")
            if len(rinsing_solvents) != rinsing_repeats:
                rinsing_solvents = [rinsing_solvent] * rinsing_repeats
        else:
            rinsing_solvents = [rinsing_solvent] * rinsing_repeats

        for solvent in rinsing_solvents:
            solvent_vessel = f"flask_{solvent.strip()}"

            # 检查溶剂容器是否存在
            if solvent_vessel not in G.nodes():
                logger.warning(f"溶剂容器 {solvent_vessel} 不存在，跳过该溶剂冲洗")
                continue

            # 清洗泵系统
            rinsing_actions.extend(
                generate_pump_protocol(G, solvent_vessel, pump_backbone[0], min_transfer_volume, flowrate,
                                       transfer_flowrate)
            )

            if len(pump_backbone) > 1:
                rinsing_actions.extend(
                    generate_pump_protocol(G, pump_backbone[0], pump_backbone[-1], min_transfer_volume, flowrate,
                                           transfer_flowrate)
                )

            # 排到废液容器
            if waste_vessel in G.nodes():
                rinsing_actions.extend(
                    generate_pump_protocol(G, pump_backbone[-1], waste_vessel, min_transfer_volume, flowrate,
                                           transfer_flowrate)
                )

            # 第一种冲洗溶剂稀释源容器和目标容器
            if solvent == rinsing_solvents[0]:
                rinsing_actions.extend(
                    generate_pump_protocol(G, solvent_vessel, from_vessel_id, rinsing_volume, flowrate,
                                           transfer_flowrate)
                )
                rinsing_actions.extend(
                    generate_pump_protocol(G, solvent_vessel, to_vessel_id, rinsing_volume, flowrate, transfer_flowrate)
                )

    except Exception as e:
        logger.error(f"生成冲洗序列失败: {str(e)}")

    return rinsing_actions


def _generate_air_rinsing_sequence(G: nx.DiGraph, from_vessel_id: str, to_vessel_id: str,
                                   rinsing_volume: float, repeats: int,
                                   flowrate: float, transfer_flowrate: float) -> List[Dict[str, Any]]:
    """生成空气冲洗序列"""
    air_rinsing_actions = []

    try:
        air_vessel = "flask_air"
        if air_vessel not in G.nodes():
            logger.warning("空气容器 flask_air 不存在，跳过空气冲洗")
            return air_rinsing_actions

        for _ in range(repeats):
            # 空气冲洗源容器
            air_rinsing_actions.extend(
                generate_pump_protocol(G, air_vessel, from_vessel_id, rinsing_volume, flowrate, transfer_flowrate)
            )

            # 空气冲洗目标容器
            air_rinsing_actions.extend(
                generate_pump_protocol(G, air_vessel, to_vessel_id, rinsing_volume, flowrate, transfer_flowrate)
            )

    except Exception as e:
        logger.warning(f"空气冲洗失败: {str(e)}")

    return air_rinsing_actions