vectorvein 0.2.50__py3-none-any.whl → 0.2.52__py3-none-any.whl

vectorvein/chat_clients/openai_compatible_client.py

@@ -331,11 +331,6 @@ class OpenAICompatibleChatClient(BaseChatClient):
             else:
                 max_tokens = self.model_setting.context_length - token_counts - 64
 
-        if response_format and self.model_setting.response_format_available:
-            self.response_format = {"response_format": response_format}
-        else:
-            self.response_format = {}
-
         self._acquire_rate_limit(self.endpoint, self.model, messages)
 
         if self.stream:
@@ -797,16 +792,6 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
         else:
             tools_params = {}
 
-        if response_format and self.model_setting.response_format_available:
-            self.response_format = {"response_format": response_format}
-        else:
-            self.response_format = {}
-
-        if stream_options:
-            _stream_options_params = {"stream_options": stream_options}
-        else:
-            _stream_options_params = {}
-
         if max_tokens is None:
             max_output_tokens = self.model_setting.max_output_tokens
             token_counts = get_message_token_counts(messages=messages, tools=tools, model=self.model)

vectorvein/chat_clients/utils.py

@@ -55,30 +55,29 @@ class ToolCallContentProcessor:
             return {}
         tool_calls_matches = re.findall(self.tool_use_re, self.content)
         if tool_calls_matches:
-            tool_call_data = {}
-            for match in tool_calls_matches:
+            tool_calls = []
+            for idx, match in enumerate(tool_calls_matches):
                 try:
                     tool_call_data = json.loads(match)
+                    arguments = json.dumps(tool_call_data["arguments"], ensure_ascii=False)
+                    tool_calls.append(
+                        {
+                            "index": idx,
+                            "id": f"call_{idx}",
+                            "function": {
+                                "arguments": arguments,
+                                "name": tool_call_data["name"],
+                            },
+                            "type": "function",
+                        }
+                    )
                 except json.JSONDecodeError:
                     print(f"Failed to parse tool call data:\nContent: {self.content}\nMatch: {match}")
 
-            if not tool_call_data:
+            if not tool_calls:
                 return {}
 
-            arguments = json.dumps(tool_call_data["arguments"], ensure_ascii=False)
-            return {
-                "tool_calls": [
-                    {
-                        "index": 0,
-                        "id": "call_0",
-                        "function": {
-                            "arguments": arguments,
-                            "name": tool_call_data["name"],
-                        },
-                        "type": "function",
-                    }
-                ]
-            }
+            return {"tool_calls": tool_calls}
         else:
             return {}
 

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,26 +1,10 @@
 import json
-from typing import List, Union, TypedDict, Dict, Any, Optional
+from typing import List, Union, Dict, Any, Optional
 
 from .node import Node
 from .edge import Edge
-from .port import InputPort
 from ..utils.layout import layout
-
-
-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.check import WorkflowCheckResult, check_dag, check_ui
 
 
 class Workflow:
@@ -135,152 +119,17 @@ 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

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.50.dist-info → vectorvein-0.2.52.dist-info}/METADATA

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

{vectorvein-0.2.50.dist-info → vectorvein-0.2.52.dist-info}/RECORD

@@ -1,6 +1,6 @@
-vectorvein-0.2.50.dist-info/METADATA,sha256=ltuWwgnho44gDn6eGM8ED7_dtnefHd1KZ89yMM4bqrY,4570
-vectorvein-0.2.50.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-vectorvein-0.2.50.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+vectorvein-0.2.52.dist-info/METADATA,sha256=duh92n055q4yiufJHbzO9O1LFwwrxyhIWOkAkkbMgUw,4570
+vectorvein-0.2.52.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+vectorvein-0.2.52.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
@@ -19,11 +19,11 @@ vectorvein/chat_clients/minimax_client.py,sha256=YOILWcsHsN5tihLTMbKJIyJr9TJREMI
 vectorvein/chat_clients/mistral_client.py,sha256=1aKSylzBDaLYcFnaBIL4-sXSzWmXfBeON9Q0rq-ziWw,534
 vectorvein/chat_clients/moonshot_client.py,sha256=gbu-6nGxx8uM_U2WlI4Wus881rFRotzHtMSoYOcruGU,526
 vectorvein/chat_clients/openai_client.py,sha256=Nz6tV45pWcsOupxjnsRsGTicbQNJWIZyxuJoJ5DGMpg,527
-vectorvein/chat_clients/openai_compatible_client.py,sha256=HOL7sgWCBgwYdiAnNPCbODqg9lhZ_IsBUqc8uQG6kRw,48572
+vectorvein/chat_clients/openai_compatible_client.py,sha256=3MEyKqlf1BtzbNpmqAHQq0JcYwlWxEzM0pOn0XNauas,47999
 vectorvein/chat_clients/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vectorvein/chat_clients/qwen_client.py,sha256=-ryh-m9PgsO0fc4ulcCmPTy1155J8YUy15uPoJQOHA0,513
 vectorvein/chat_clients/stepfun_client.py,sha256=zsD2W5ahmR4DD9cqQTXmJr3txrGuvxbRWhFlRdwNijI,519
-vectorvein/chat_clients/utils.py,sha256=gpayOz5rfoINCAZRiKof5k4z_P2iW2XUxz6DQaheyRU,29393
+vectorvein/chat_clients/utils.py,sha256=k9Y-sZvBSqZvWhN7oGIYeE7xV2cGRvgITB_DUtB04_4,29474
 vectorvein/chat_clients/xai_client.py,sha256=eLFJJrNRJ-ni3DpshODcr3S1EJQLbhVwxyO1E54LaqM,491
 vectorvein/chat_clients/yi_client.py,sha256=RNf4CRuPJfixrwLZ3-DEc3t25QDe1mvZeb9sku2f8Bc,484
 vectorvein/chat_clients/zhipuai_client.py,sha256=Ys5DSeLCuedaDXr3PfG1EW2zKXopt-awO2IylWSwY0s,519
@@ -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=rXLIKQiOFjyP3YwYf0deHUcRNBCHJcTGj2omM4a9SpE,12070
+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,6 +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/workflow/utils/layout.py,sha256=j0bRD3uaXu40xCS6U6BGahBI8FrHa5MiF55GbTrZ1LM,4565
-vectorvein-0.2.50.dist-info/RECORD,,
+vectorvein-0.2.52.dist-info/RECORD,,