vectorvein 0.2.49__py3-none-any.whl → 0.2.51__py3-none-any.whl

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/workflow/graph/workflow.py

@@ -1,25 +1,10 @@
 import json
-from typing import List, Union, TypedDict
+from typing import List, Union, Dict, Any, Optional
 
 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相关警告
+from ..utils.layout import layout
+from ..utils.check import WorkflowCheckResult, check_dag, check_ui
 
 
 class Workflow:
@@ -134,152 +119,36 @@ class Workflow:
 
         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()
+        dag_check = check_dag(self)  # 检查流程图是否为有向无环图，并检测是否存在孤立节点。
+        ui_check = check_ui(self)
 
         # 合并结果
-        result: WorkflowCheckResult = dag_check
+        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/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/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.dist-info → vectorvein-0.2.51.dist-info}/METADATA

@@ -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.dist-info → vectorvein-0.2.51.dist-info}/RECORD

@@ -1,6 +1,6 @@
-vectorvein-0.2.49.dist-info/METADATA,sha256=uVJ6y78HdLXEXH_RZx9jbM8NlQrGHN4klzbxog1PAvs,4570
-vectorvein-0.2.49.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-vectorvein-0.2.49.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+vectorvein-0.2.51.dist-info/METADATA,sha256=N4nBBY1TFDSERO5aA57Gys1IGVCcZYGqtML8KRVMjdY,4570
+vectorvein-0.2.51.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+vectorvein-0.2.51.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
 vectorvein/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vectorvein/api/__init__.py,sha256=lfY-XA46fgD2iIZTU0VYP8i07AwA03Egj4Qua0vUKrQ,738
 vectorvein/api/client.py,sha256=xF-leKDQzVyyy9FnIRaz0k4eElYW1XbbzeRLcpnyk90,33047
@@ -42,9 +42,9 @@ vectorvein/utilities/media_processing.py,sha256=7KtbLFzOYIn1e9QTN9G6C76NH8CBlV9k
 vectorvein/utilities/rate_limiter.py,sha256=dwolIUVw2wP83Odqpx0AAaE77de1GzxkYDGH4tM_u_4,10300
 vectorvein/utilities/retry.py,sha256=6KFS9R2HdhqM3_9jkjD4F36ZSpEx2YNFGOVlpOsUetM,2208
 vectorvein/workflow/graph/edge.py,sha256=1ckyyjCue_PLm7P1ItUfKOy6AKkemOpZ9m1WJ8UXIHQ,1072
-vectorvein/workflow/graph/node.py,sha256=U3LAq01wOaDANVUuYWc2BhIq-Pl2-33FirJZkkNL_wA,5329
+vectorvein/workflow/graph/node.py,sha256=6W9czon4JpWPcjwfN1B5-igEbifRsMemjGByZxa68RY,5047
 vectorvein/workflow/graph/port.py,sha256=_QpHCBGAu657VhYAh0Wzjri3ZZ8-WYJp99J465mqmwo,6492
-vectorvein/workflow/graph/workflow.py,sha256=jDa8dedgtW39Gx0PrqgYrs7XQ_NfQbhgGge88xElksI,11159
+vectorvein/workflow/graph/workflow.py,sha256=W2ucuclAjtqjHOmvhLx1lWmFw1xMKMCKaYSV66NdDwo,5835
 vectorvein/workflow/nodes/__init__.py,sha256=dWrWtL3q0Vsn-MLgJ7gNgLCrwZ5BrqjrN2QFPNeBMuc,3240
 vectorvein/workflow/nodes/audio_generation.py,sha256=ZRFZ_ycMTSJ2LKmekctagQdJYTl-3q4TNOIKETpS9AM,5870
 vectorvein/workflow/nodes/control_flows.py,sha256=l8CjFQlsGV3fNGM6SVzS1Kz361K1xDv1fGT7acuDXuU,6613
@@ -61,5 +61,7 @@ vectorvein/workflow/nodes/triggers.py,sha256=BolH4X6S8HSuU2kwHmYKr-ozHbgKBmdZRcn
 vectorvein/workflow/nodes/vector_db.py,sha256=t6I17q6iR3yQreiDHpRrksMdWDPIvgqJs076z-7dlQQ,5712
 vectorvein/workflow/nodes/video_generation.py,sha256=qmdg-t_idpxq1veukd-jv_ChICMOoInKxprV9Z4Vi2w,4118
 vectorvein/workflow/nodes/web_crawlers.py,sha256=BhJBX1AZH7-22Gu95Ox4qJqmH5DU-m4dbUb5N5DTA-M,5559
+vectorvein/workflow/utils/check.py,sha256=BJ-Di_6UROoeu_1KQB1AaBi0xdegSBT93VdB-RqI5eY,6085
 vectorvein/workflow/utils/json_to_code.py,sha256=F7dhDy8kGc8ndOeihGLRLGFGlquoxVlb02ENtxnQ0C8,5914
-vectorvein-0.2.49.dist-info/RECORD,,
+vectorvein/workflow/utils/layout.py,sha256=j0bRD3uaXu40xCS6U6BGahBI8FrHa5MiF55GbTrZ1LM,4565
+vectorvein-0.2.51.dist-info/RECORD,,