vectorvein 0.2.49__tar.gz → 0.2.51__tar.gz

{vectorvein-0.2.49 → vectorvein-0.2.51}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vectorvein
-Version: 0.2.49
+Version: 0.2.51
 Summary: VectorVein Python SDK
 Author-Email: Anderson <andersonby@163.com>
 License: MIT

{vectorvein-0.2.49 → vectorvein-0.2.51}/pyproject.toml

@@ -17,7 +17,7 @@ description = "VectorVein Python SDK"
 name = "vectorvein"
 readme = "README.md"
 requires-python = ">=3.10"
-version = "0.2.49"
+version = "0.2.51"
 
 [project.license]
 text = "MIT"

{vectorvein-0.2.49 → vectorvein-0.2.51}/src/vectorvein/workflow/graph/node.py

@@ -10,15 +10,13 @@ class PortsDict(Dict[str, Port]):
     def __init__(self, owner_node: "Node", *args, **kwargs):
         super().__init__(*args, **kwargs)
         self._owner_node = owner_node
-        self._initializing = True  # 初始化标志
+        self._initializing = True
 
     def __setitem__(self, key: str, value: Port) -> None:
-        # 初始化阶段或端口已存在时，允许直接添加/更新
         if self._initializing or key in self:
             super().__setitem__(key, value)
             return
 
-        # 对于新端口，检查添加权限
         if isinstance(value, OutputPort) and not self._owner_node.can_add_output_ports:
             raise ValueError(
                 f"Node<{self._owner_node.id}> '{self._owner_node.type}' does not allow adding output ports"
@@ -58,13 +56,11 @@ class Node:
         self.description: str = description
         self.can_add_input_ports: bool = can_add_input_ports
         self.can_add_output_ports: bool = can_add_output_ports
-        # 初始化自定义PortsDict
+
         self.ports = PortsDict(self)
-        # 如果提供了初始端口，将它们添加到字典中
         if ports:
             for name, port in ports.items():
                 self.ports[name] = port
-        # 结束初始化阶段
         self.ports.finish_initialization()
 
         self.position: Dict[str, float] = position or {"x": 0, "y": 0}

vectorvein-0.2.51/src/vectorvein/workflow/graph/workflow.py

@@ -0,0 +1,154 @@
+import json
+from typing import List, Union, Dict, Any, Optional
+
+from .node import Node
+from .edge import Edge
+from ..utils.layout import layout
+from ..utils.check import WorkflowCheckResult, check_dag, check_ui
+
+
+class Workflow:
+    def __init__(self) -> None:
+        self.nodes: List[Node] = []
+        self.edges: List[Edge] = []
+
+    def add_node(self, node: Node):
+        self.nodes.append(node)
+
+    def add_nodes(self, nodes: List[Node]):
+        self.nodes.extend(nodes)
+
+    def add_edge(self, edge: Edge):
+        self.edges.append(edge)
+
+    def connect(
+        self,
+        source_node: Union[str, Node],
+        source_port: str,
+        target_node: Union[str, Node],
+        target_port: str,
+    ):
+        # 获取源节点ID
+        if isinstance(source_node, Node):
+            source_node_id = source_node.id
+        else:
+            source_node_id = source_node
+
+        # 获取目标节点ID
+        if isinstance(target_node, Node):
+            target_node_id = target_node.id
+        else:
+            target_node_id = target_node
+
+        # 检查源节点是否存在
+        source_node_exists = any(node.id == source_node_id for node in self.nodes)
+        if not source_node_exists:
+            raise ValueError(f"Source node not found: {source_node_id}")
+
+        # 检查目标节点是否存在
+        target_node_exists = any(node.id == target_node_id for node in self.nodes)
+        if not target_node_exists:
+            raise ValueError(f"Target node not found: {target_node_id}")
+
+        # 检查源节点的端口是否存在
+        source_node_obj = next(node for node in self.nodes if node.id == source_node_id)
+        if not source_node_obj.has_output_port(source_port):
+            raise ValueError(f"Source node {source_node_id} has no output port: {source_port}")
+
+        # 检查目标节点的端口是否存在
+        target_node_obj = next(node for node in self.nodes if node.id == target_node_id)
+        if not target_node_obj.has_input_port(target_port):
+            raise ValueError(f"Target node {target_node_id} has no input port: {target_port}")
+
+        # 检查目标端口是否已有被连接的线
+        for edge in self.edges:
+            if edge.target == target_node_id and edge.target_handle == target_port:
+                raise ValueError(
+                    f"The input port {target_port} of the target node {target_node_id} is already connected: {edge.source}({edge.source_handle}) → {edge.target}({edge.target_handle})"
+                )
+
+        # 创建并添加边
+        edge_id = f"vueflow__edge-{source_node_id}{source_port}-{target_node_id}{target_port}"
+        edge = Edge(edge_id, source_node_id, source_port, target_node_id, target_port)
+        self.add_edge(edge)
+
+    def to_dict(self):
+        return {
+            "nodes": [node.to_dict() for node in self.nodes],
+            "edges": [edge.to_dict() for edge in self.edges],
+            "viewport": {"x": 0, "y": 0, "zoom": 1},
+        }
+
+    def to_json(self, ensure_ascii=False):
+        return json.dumps(self.to_dict(), ensure_ascii=ensure_ascii)
+
+    def to_mermaid(self) -> str:
+        """生成 Mermaid 格式的流程图。
+
+        Returns:
+            str: Mermaid 格式的流程图文本
+        """
+        lines = ["flowchart TD"]
+
+        # 创建节点类型到序号的映射
+        type_counters = {}
+        node_id_to_label = {}
+
+        # 首先为所有节点生成标签
+        for node in self.nodes:
+            node_type = node.type.lower()
+            if node_type not in type_counters:
+                type_counters[node_type] = 0
+            node_label = f"{node_type}_{type_counters[node_type]}"
+            node_id_to_label[node.id] = node_label
+            type_counters[node_type] += 1
+
+        # 添加节点定义
+        for node in self.nodes:
+            node_label = node_id_to_label[node.id]
+            lines.append(f'    {node_label}["{node_label} ({node.type})"]')
+
+        lines.append("")  # 添加一个空行分隔节点和边的定义
+
+        # 添加边的定义
+        for edge in self.edges:
+            source_label = node_id_to_label[edge.source]
+            target_label = node_id_to_label[edge.target]
+            label = f"{edge.source_handle} → {edge.target_handle}"
+            lines.append(f"    {source_label} -->|{label}| {target_label}")
+
+        return "\n".join(lines)
+
+    def check(self) -> WorkflowCheckResult:
+        """检查流程图的有效性。
+
+        Returns:
+            WorkflowCheckResult: 包含各种检查结果的字典
+        """
+        dag_check = check_dag(self)  # 检查流程图是否为有向无环图，并检测是否存在孤立节点。
+        ui_check = check_ui(self)
+
+        # 合并结果
+        result = dag_check
+        result["ui_warnings"] = ui_check
+
+        return result
+
+    def layout(self, options: Optional[Dict[str, Any]] = None) -> "Workflow":
+        """对工作流中的节点进行自动布局，计算并更新每个节点的位置。
+
+        此方法实现了一个简单的分层布局算法，将节点按照有向图的拓扑结构进行排列。
+
+        Args:
+            options: 布局选项，包括:
+                - direction: 布局方向 ('TB', 'BT', 'LR', 'RL')，默认 'LR'
+                - node_spacing: 同一层级节点间的间距，默认 500
+                - layer_spacing: 不同层级间的间距，默认 400
+                - margin_x: 图形左右边距，默认 20
+                - margin_y: 图形上下边距，默认 20
+
+        Returns:
+            布局后的工作流对象
+        """
+        layout(self.nodes, self.edges, options)
+        return self

vectorvein-0.2.51/src/vectorvein/workflow/utils/check.py

@@ -0,0 +1,159 @@
+from typing import TypedDict, TYPE_CHECKING
+
+from ..graph.port import InputPort
+
+if TYPE_CHECKING:
+    from ..graph.workflow import Workflow
+
+
+class UIWarning(TypedDict, total=False):
+    """UI警告类型。"""
+
+    input_ports_shown_but_connected: list[dict]  # 显示的输入端口但被连接
+    has_shown_input_ports: bool  # 是否存在显示的输入端口
+    has_output_nodes: bool  # 是否存在输出节点
+
+
+class WorkflowCheckResult(TypedDict, total=False):
+    """工作流检查结果类型。"""
+
+    no_cycle: bool  # 工作流是否不包含环
+    no_isolated_nodes: bool  # 工作流是否不包含孤立节点
+    ui_warnings: UIWarning  # UI相关警告
+
+
+def check_dag(workflow: "Workflow") -> WorkflowCheckResult:
+    """检查流程图是否为有向无环图，并检测是否存在孤立节点。
+
+    Returns:
+        WorkflowCheckResult: 包含检查结果的字典
+            - no_cycle (bool): 如果流程图是有向无环图返回 True，否则返回 False
+            - no_isolated_nodes (bool): 如果不存在孤立节点返回 True，否则返回 False
+    """
+    result: WorkflowCheckResult = {"no_cycle": True, "no_isolated_nodes": True}
+
+    # 过滤掉触发器节点和辅助节点
+    trigger_nodes = [
+        node.id
+        for node in workflow.nodes
+        if hasattr(node, "category") and (node.category == "triggers" or node.category == "assistedNodes")
+    ]
+
+    # 获取需要检查的节点和边
+    regular_nodes = [node.id for node in workflow.nodes if node.id not in trigger_nodes]
+    regular_edges = [
+        edge for edge in workflow.edges if edge.source not in trigger_nodes and edge.target not in trigger_nodes
+    ]
+
+    # ---------- 检查有向图是否有环 ----------
+    # 构建邻接表
+    adjacency = {node_id: [] for node_id in regular_nodes}
+    for edge in regular_edges:
+        if edge.source in adjacency:  # 确保节点在字典中
+            adjacency[edge.source].append(edge.target)
+
+    # 三种状态: 0 = 未访问, 1 = 正在访问, 2 = 已访问完成
+    visited = {node_id: 0 for node_id in regular_nodes}
+
+    def dfs_cycle_detection(node_id):
+        # 如果节点正在被访问，说明找到了环
+        if visited[node_id] == 1:
+            return False
+
+        # 如果节点已经访问完成，无需再次访问
+        if visited[node_id] == 2:
+            return True
+
+        # 标记为正在访问
+        visited[node_id] = 1
+
+        # 访问所有邻居
+        for neighbor in adjacency[node_id]:
+            if neighbor in visited and not dfs_cycle_detection(neighbor):
+                return False
+
+        # 标记为已访问完成
+        visited[node_id] = 2
+        return True
+
+    # 对每个未访问的节点进行 DFS 检测环
+    for node_id in regular_nodes:
+        if visited[node_id] == 0:
+            if not dfs_cycle_detection(node_id):
+                result["no_cycle"] = False
+                break
+
+    # ---------- 检查是否存在孤立节点 ----------
+    # 构建无向图邻接表
+    undirected_adjacency = {node_id: [] for node_id in regular_nodes}
+    for edge in regular_edges:
+        if edge.source in undirected_adjacency and edge.target in undirected_adjacency:
+            undirected_adjacency[edge.source].append(edge.target)
+            undirected_adjacency[edge.target].append(edge.source)
+
+    # 深度优先搜索来检测连通分量
+    undirected_visited = set()
+
+    def dfs_connected_components(node_id):
+        undirected_visited.add(node_id)
+        for neighbor in undirected_adjacency[node_id]:
+            if neighbor not in undirected_visited:
+                dfs_connected_components(neighbor)
+
+    # 计算连通分量数量
+    connected_components_count = 0
+    for node_id in regular_nodes:
+        if node_id not in undirected_visited:
+            connected_components_count += 1
+            dfs_connected_components(node_id)
+
+    # 如果连通分量数量大于1，说明存在孤立节点
+    if connected_components_count > 1 and len(regular_nodes) > 0:
+        result["no_isolated_nodes"] = False
+
+    return result
+
+
+def check_ui(workflow: "Workflow") -> UIWarning:
+    """
+    检查工作流的 UI 情况。
+    以下情况会警告：
+    1. 某个输入端口的 show=True，但是又有连线连接到该端口（实际运行时会被覆盖）。
+    2. 整个工作流没有任何输入端口是 show=True 的，说明没有让用户输入的地方。
+    3. 整个工作流没有任何输出节点，这样工作流结果无法呈现。
+    """
+    warnings: UIWarning = {
+        "input_ports_shown_but_connected": [],
+        "has_shown_input_ports": False,
+        "has_output_nodes": False,
+    }
+
+    # 检查是否有任何显示的输入端口
+    has_shown_input_ports = False
+
+    # 找出所有连接的目标端口
+    connected_ports = {(edge.target, edge.target_handle) for edge in workflow.edges}
+
+    # 遍历所有节点
+    for node in workflow.nodes:
+        # 检查是否为输出节点
+        if hasattr(node, "category") and node.category == "outputs":
+            warnings["has_output_nodes"] = True
+
+        # 检查节点的输入端口
+        for port_name in node.ports.keys() if hasattr(node, "ports") else []:
+            port = node.ports.get(port_name)
+            # 确保是输入端口且设置为显示
+            if hasattr(port, "show") and getattr(port, "show", False) and isinstance(port, InputPort):
+                has_shown_input_ports = True
+
+                # 检查显示的端口是否也被连接
+                if (node.id, port_name) in connected_ports:
+                    warnings["input_ports_shown_but_connected"].append(
+                        {"node_id": node.id, "node_type": node.type, "port_name": port_name}
+                    )
+
+    # 如果没有任何显示的输入端口
+    warnings["has_shown_input_ports"] = has_shown_input_ports
+
+    return warnings

vectorvein-0.2.51/src/vectorvein/workflow/utils/layout.py

@@ -0,0 +1,114 @@
+from typing import Optional, Dict, Any, List, TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from vectorvein.workflow.graph.node import Node
+    from vectorvein.workflow.graph.edge import Edge
+
+
+def layout(nodes: List["Node"], edges: List["Edge"], options: Optional[Dict[str, Any]] = None):
+    """对工作流中的节点进行自动布局，计算并更新每个节点的位置。
+
+    此方法实现了一个简单的分层布局算法，将节点按照有向图的拓扑结构进行排列。
+
+    Args:
+        options: 布局选项，包括:
+            - direction: 布局方向 ('TB', 'BT', 'LR', 'RL')，默认 'TB'
+            - node_spacing: 同一层级节点间的间距，默认 150
+            - layer_spacing: 不同层级间的间距，默认 100
+            - margin_x: 图形左右边距，默认 20
+            - margin_y: 图形上下边距，默认 20
+
+    Returns:
+        布局后的工作流对象
+    """
+    # 设置默认选项
+    default_options = {
+        "direction": "LR",  # 从上到下的布局
+        "node_spacing": 400,  # 同一层级节点间的间距
+        "layer_spacing": 500,  # 不同层级间的间距
+        "margin_x": 20,  # 图形左右边距
+        "margin_y": 20,  # 图形上下边距
+    }
+
+    # 合并用户提供的选项
+    if options:
+        default_options.update(options)
+
+    # 构建邻接表
+    adjacency = {node.id: [] for node in nodes}
+    in_degree = {node.id: 0 for node in nodes}
+
+    for edge in edges:
+        if edge.source in adjacency:
+            adjacency[edge.source].append(edge.target)
+            in_degree[edge.target] = in_degree.get(edge.target, 0) + 1
+
+    # 找出所有入度为0的节点（根节点）
+    roots = [node_id for node_id, degree in in_degree.items() if degree == 0]
+
+    # 如果没有根节点，选择第一个节点作为起点
+    if not roots and nodes:
+        roots = [nodes[0].id]
+
+    # 按层级排列节点
+    layers = []
+    visited = set()
+
+    current_layer = roots
+    while current_layer:
+        layers.append(current_layer)
+        next_layer = []
+        for node_id in current_layer:
+            visited.add(node_id)
+            for neighbor in adjacency.get(node_id, []):
+                if neighbor not in visited and all(
+                    parent in visited for parent in [e.source for e in edges if e.target == neighbor]
+                ):
+                    next_layer.append(neighbor)
+        current_layer = next_layer
+
+    # 还有未访问的节点（可能是孤立节点或环的一部分）
+    remaining = [node.id for node in nodes if node.id not in visited]
+    if remaining:
+        layers.append(remaining)
+
+    # 根据层级信息设置节点位置
+    layer_spacing = default_options["layer_spacing"]
+    node_spacing = default_options["node_spacing"]
+    margin_x = default_options["margin_x"]
+    margin_y = default_options["margin_y"]
+
+    # 布局方向
+    is_vertical = default_options["direction"] in ["TB", "BT"]
+    is_reversed = default_options["direction"] in ["BT", "RL"]
+
+    for layer_idx, layer in enumerate(layers):
+        for node_idx, node_id in enumerate(layer):
+            # 根据布局方向计算位置
+            if is_vertical:
+                # 垂直布局 (TB 或 BT)
+                x = node_idx * node_spacing + margin_x
+                y = layer_idx * layer_spacing + margin_y
+                if is_reversed:  # BT 布局需要反转 y 坐标
+                    y = (len(layers) - 1 - layer_idx) * layer_spacing + margin_y
+            else:
+                # 水平布局 (LR 或 RL)
+                x = layer_idx * layer_spacing + margin_x
+                y = node_idx * node_spacing + margin_y
+                if is_reversed:  # RL 布局需要反转 x 坐标
+                    x = (len(layers) - 1 - layer_idx) * layer_spacing + margin_x
+
+            # 找到节点对象并设置位置
+            for node in nodes:
+                if node.id == node_id:
+                    # 确保节点有 position 属性
+                    if not hasattr(node, "position"):
+                        node.position = {"x": x, "y": y}
+                    else:
+                        # 如果已经有 position 属性，更新它
+                        if isinstance(node.position, dict):
+                            node.position.update({"x": x, "y": y})
+                        else:
+                            node.position = {"x": x, "y": y}
+                    break

vectorvein-0.2.49/src/vectorvein/workflow/graph/workflow.py

@@ -1,285 +0,0 @@
-import json
-from typing import List, Union, TypedDict
-
-from .node import Node
-from .edge import Edge
-from .port import InputPort
-
-
-class UIWarning(TypedDict, total=False):
-    """UI警告类型。"""
-
-    input_ports_shown_but_connected: list[dict]  # 显示的输入端口但被连接
-    has_shown_input_ports: bool  # 是否存在显示的输入端口
-    has_output_nodes: bool  # 是否存在输出节点
-
-
-class WorkflowCheckResult(TypedDict, total=False):
-    """工作流检查结果类型。"""
-
-    no_cycle: bool  # 工作流是否不包含环
-    no_isolated_nodes: bool  # 工作流是否不包含孤立节点
-    ui_warnings: UIWarning  # UI相关警告
-
-
-class Workflow:
-    def __init__(self) -> None:
-        self.nodes: List[Node] = []
-        self.edges: List[Edge] = []
-
-    def add_node(self, node: Node):
-        self.nodes.append(node)
-
-    def add_nodes(self, nodes: List[Node]):
-        self.nodes.extend(nodes)
-
-    def add_edge(self, edge: Edge):
-        self.edges.append(edge)
-
-    def connect(
-        self,
-        source_node: Union[str, Node],
-        source_port: str,
-        target_node: Union[str, Node],
-        target_port: str,
-    ):
-        # 获取源节点ID
-        if isinstance(source_node, Node):
-            source_node_id = source_node.id
-        else:
-            source_node_id = source_node
-
-        # 获取目标节点ID
-        if isinstance(target_node, Node):
-            target_node_id = target_node.id
-        else:
-            target_node_id = target_node
-
-        # 检查源节点是否存在
-        source_node_exists = any(node.id == source_node_id for node in self.nodes)
-        if not source_node_exists:
-            raise ValueError(f"Source node not found: {source_node_id}")
-
-        # 检查目标节点是否存在
-        target_node_exists = any(node.id == target_node_id for node in self.nodes)
-        if not target_node_exists:
-            raise ValueError(f"Target node not found: {target_node_id}")
-
-        # 检查源节点的端口是否存在
-        source_node_obj = next(node for node in self.nodes if node.id == source_node_id)
-        if not source_node_obj.has_output_port(source_port):
-            raise ValueError(f"Source node {source_node_id} has no output port: {source_port}")
-
-        # 检查目标节点的端口是否存在
-        target_node_obj = next(node for node in self.nodes if node.id == target_node_id)
-        if not target_node_obj.has_input_port(target_port):
-            raise ValueError(f"Target node {target_node_id} has no input port: {target_port}")
-
-        # 检查目标端口是否已有被连接的线
-        for edge in self.edges:
-            if edge.target == target_node_id and edge.target_handle == target_port:
-                raise ValueError(
-                    f"The input port {target_port} of the target node {target_node_id} is already connected: {edge.source}({edge.source_handle}) → {edge.target}({edge.target_handle})"
-                )
-
-        # 创建并添加边
-        edge_id = f"vueflow__edge-{source_node_id}{source_port}-{target_node_id}{target_port}"
-        edge = Edge(edge_id, source_node_id, source_port, target_node_id, target_port)
-        self.add_edge(edge)
-
-    def to_dict(self):
-        return {
-            "nodes": [node.to_dict() for node in self.nodes],
-            "edges": [edge.to_dict() for edge in self.edges],
-            "viewport": {"x": 0, "y": 0, "zoom": 1},
-        }
-
-    def to_json(self, ensure_ascii=False):
-        return json.dumps(self.to_dict(), ensure_ascii=ensure_ascii)
-
-    def to_mermaid(self) -> str:
-        """生成 Mermaid 格式的流程图。
-
-        Returns:
-            str: Mermaid 格式的流程图文本
-        """
-        lines = ["flowchart TD"]
-
-        # 创建节点类型到序号的映射
-        type_counters = {}
-        node_id_to_label = {}
-
-        # 首先为所有节点生成标签
-        for node in self.nodes:
-            node_type = node.type.lower()
-            if node_type not in type_counters:
-                type_counters[node_type] = 0
-            node_label = f"{node_type}_{type_counters[node_type]}"
-            node_id_to_label[node.id] = node_label
-            type_counters[node_type] += 1
-
-        # 添加节点定义
-        for node in self.nodes:
-            node_label = node_id_to_label[node.id]
-            lines.append(f'    {node_label}["{node_label} ({node.type})"]')
-
-        lines.append("")  # 添加一个空行分隔节点和边的定义
-
-        # 添加边的定义
-        for edge in self.edges:
-            source_label = node_id_to_label[edge.source]
-            target_label = node_id_to_label[edge.target]
-            label = f"{edge.source_handle} → {edge.target_handle}"
-            lines.append(f"    {source_label} -->|{label}| {target_label}")
-
-        return "\n".join(lines)
-
-    def _check_dag(self) -> WorkflowCheckResult:
-        """检查流程图是否为有向无环图，并检测是否存在孤立节点。
-
-        Returns:
-            WorkflowCheckResult: 包含检查结果的字典
-                - no_cycle (bool): 如果流程图是有向无环图返回 True，否则返回 False
-                - no_isolated_nodes (bool): 如果不存在孤立节点返回 True，否则返回 False
-        """
-        result: WorkflowCheckResult = {"no_cycle": True, "no_isolated_nodes": True}
-
-        # 过滤掉触发器节点和辅助节点
-        trigger_nodes = [
-            node.id
-            for node in self.nodes
-            if hasattr(node, "category") and (node.category == "triggers" or node.category == "assistedNodes")
-        ]
-
-        # 获取需要检查的节点和边
-        regular_nodes = [node.id for node in self.nodes if node.id not in trigger_nodes]
-        regular_edges = [
-            edge for edge in self.edges if edge.source not in trigger_nodes and edge.target not in trigger_nodes
-        ]
-
-        # ---------- 检查有向图是否有环 ----------
-        # 构建邻接表
-        adjacency = {node_id: [] for node_id in regular_nodes}
-        for edge in regular_edges:
-            if edge.source in adjacency:  # 确保节点在字典中
-                adjacency[edge.source].append(edge.target)
-
-        # 三种状态: 0 = 未访问, 1 = 正在访问, 2 = 已访问完成
-        visited = {node_id: 0 for node_id in regular_nodes}
-
-        def dfs_cycle_detection(node_id):
-            # 如果节点正在被访问，说明找到了环
-            if visited[node_id] == 1:
-                return False
-
-            # 如果节点已经访问完成，无需再次访问
-            if visited[node_id] == 2:
-                return True
-
-            # 标记为正在访问
-            visited[node_id] = 1
-
-            # 访问所有邻居
-            for neighbor in adjacency[node_id]:
-                if neighbor in visited and not dfs_cycle_detection(neighbor):
-                    return False
-
-            # 标记为已访问完成
-            visited[node_id] = 2
-            return True
-
-        # 对每个未访问的节点进行 DFS 检测环
-        for node_id in regular_nodes:
-            if visited[node_id] == 0:
-                if not dfs_cycle_detection(node_id):
-                    result["no_cycle"] = False
-                    break
-
-        # ---------- 检查是否存在孤立节点 ----------
-        # 构建无向图邻接表
-        undirected_adjacency = {node_id: [] for node_id in regular_nodes}
-        for edge in regular_edges:
-            if edge.source in undirected_adjacency and edge.target in undirected_adjacency:
-                undirected_adjacency[edge.source].append(edge.target)
-                undirected_adjacency[edge.target].append(edge.source)
-
-        # 深度优先搜索来检测连通分量
-        undirected_visited = set()
-
-        def dfs_connected_components(node_id):
-            undirected_visited.add(node_id)
-            for neighbor in undirected_adjacency[node_id]:
-                if neighbor not in undirected_visited:
-                    dfs_connected_components(neighbor)
-
-        # 计算连通分量数量
-        connected_components_count = 0
-        for node_id in regular_nodes:
-            if node_id not in undirected_visited:
-                connected_components_count += 1
-                dfs_connected_components(node_id)
-
-        # 如果连通分量数量大于1，说明存在孤立节点
-        if connected_components_count > 1 and len(regular_nodes) > 0:
-            result["no_isolated_nodes"] = False
-
-        return result
-
-    def _check_ui(self) -> UIWarning:
-        """
-        检查工作流的 UI 情况。
-        以下情况会警告：
-        1. 某个输入端口的 show=True，但是又有连线连接到该端口（实际运行时会被覆盖）。
-        2. 整个工作流没有任何输入端口是 show=True 的，说明没有让用户输入的地方。
-        3. 整个工作流没有任何输出节点，这样工作流结果无法呈现。
-        """
-        warnings: UIWarning = {
-            "input_ports_shown_but_connected": [],
-            "has_shown_input_ports": False,
-            "has_output_nodes": False,
-        }
-
-        # 检查是否有任何显示的输入端口
-        has_shown_input_ports = False
-
-        # 找出所有连接的目标端口
-        connected_ports = {(edge.target, edge.target_handle) for edge in self.edges}
-
-        # 遍历所有节点
-        for node in self.nodes:
-            # 检查是否为输出节点
-            if hasattr(node, "category") and node.category == "outputs":
-                warnings["has_output_nodes"] = True
-
-            # 检查节点的输入端口
-            for port_name in node.ports.keys() if hasattr(node, "ports") else []:
-                port = node.ports.get(port_name)
-                # 确保是输入端口且设置为显示
-                if hasattr(port, "show") and getattr(port, "show", False) and isinstance(port, InputPort):
-                    has_shown_input_ports = True
-
-                    # 检查显示的端口是否也被连接
-                    if (node.id, port_name) in connected_ports:
-                        warnings["input_ports_shown_but_connected"].append(
-                            {"node_id": node.id, "node_type": node.type, "port_name": port_name}
-                        )
-
-        # 如果没有任何显示的输入端口
-        warnings["has_shown_input_ports"] = has_shown_input_ports
-
-        return warnings
-
-    def check(self) -> WorkflowCheckResult:
-        """检查流程图的有效性。
-
-        Returns:
-            WorkflowCheckResult: 包含各种检查结果的字典
-        """
-        dag_check = self._check_dag()
-        ui_check = self._check_ui()
-
-        # 合并结果
-        result: WorkflowCheckResult = dag_check
-        result["ui_warnings"] = ui_check
-
-        return result