vectorvein 0.1.79__py3-none-any.whl → 0.1.81__py3-none-any.whl

vectorvein/types/defaults.py

@@ -698,6 +698,14 @@ GEMINI_MODELS: Final[Dict[str, Dict[str, Any]]] = {
         "response_format_available": True,
         "native_multimodal": False,
     },
+    "gemini-2.0-flash-thinking-exp-01-21": {
+        "id": "gemini-2.0-flash-thinking-exp-01-21",
+        "context_length": 1048576,
+        "max_output_tokens": 8192,
+        "function_call_available": True,
+        "response_format_available": True,
+        "native_multimodal": False,
+    },
     "gemini-exp-1206": {
         "id": "gemini-exp-1206",
         "context_length": 2097152,

vectorvein/workflow/graph/edge.py

@@ -0,0 +1,36 @@
+from typing import Dict, Any, Union
+
+
+class Edge:
+    def __init__(
+        self,
+        id: str,
+        source: str,
+        sourceHandle: str,
+        target: str,
+        targetHandle: str,
+        animated: bool = True,
+        type: str = "default",
+    ) -> None:
+        self.id: str = id
+        self.source: str = source
+        self.sourceHandle: str = sourceHandle
+        self.target: str = target
+        self.targetHandle: str = targetHandle
+        self.animated: bool = animated
+        self.type: str = type
+        self.style: Dict[str, Union[str, int]] = {"stroke": "#28c5e5", "strokeWidth": 3}
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "source": self.source,
+            "sourceHandle": self.sourceHandle,
+            "target": self.target,
+            "targetHandle": self.targetHandle,
+            "animated": self.animated,
+            "type": self.type,
+            "style": self.style,
+            "data": {},
+            "label": "",
+        }

vectorvein/workflow/graph/node.py

@@ -0,0 +1,82 @@
+import uuid
+from typing import Dict, Any, Optional, List, Union
+
+from .port import PortType, Port, InputPort, OutputPort
+
+
+class Node:
+    def __init__(
+        self,
+        node_type: str,
+        category: str,
+        task_name: str,
+        description: str = "",
+        ports: Optional[Dict[str, Any]] = None,
+        node_id: Optional[str] = None,
+        position: Optional[Dict[str, float]] = None,
+        seleted_workflow_title: str = "",
+        is_template: bool = False,
+        initialized: bool = False,
+    ) -> None:
+        self.id: str = node_id or str(uuid.uuid4())
+        self.type: str = node_type
+        self.category: str = category
+        self.task_name: str = task_name
+        self.description: str = description
+        self.ports: Dict[str, Port] = ports or {}
+        self.position: Dict[str, float] = position or {"x": 0, "y": 0}
+        self.seleted_workflow_title: str = seleted_workflow_title
+        self.is_template: bool = is_template
+        self.initialized: bool = initialized
+        self.ignored: bool = False
+        self.lock: bool = False
+        self.shadow: bool = False
+
+    def add_port(
+        self,
+        name: str,
+        port_type: Union[PortType, str],
+        show: bool = False,
+        value: Any = None,
+        options: Optional[List[Any]] = None,
+        is_output: bool = False,
+        **kwargs,
+    ):
+        if is_output:
+            self.ports[name] = OutputPort(
+                name=name, port_type=port_type, show=show, value=value, options=options, **kwargs
+            )
+        else:
+            self.ports[name] = InputPort(
+                name=name, port_type=port_type, show=show, value=value, options=options, **kwargs
+            )
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "type": self.type,
+            "data": {
+                "task_name": self.task_name,
+                "has_inputs": self.has_inputs(),
+                "description": self.description,
+                "seleted_workflow_title": self.seleted_workflow_title,
+                "is_template": self.is_template,
+                "template": {
+                    port_name: port.to_dict()
+                    for port_name, port in self.ports.items()
+                    if port_name not in ["debug", "seleted_workflow_title", "is_template"]
+                },
+            },
+            "category": self.category,
+            "position": self.position,
+            "initialized": self.initialized,
+            "ignored": self.ignored,
+            "lock": self.lock,
+            "shadow": self.shadow,
+        }
+
+    def has_inputs(self) -> bool:
+        for port in self.ports.values():
+            if isinstance(port, InputPort):
+                return True
+        return False

vectorvein/workflow/graph/port.py

@@ -0,0 +1,173 @@
+from enum import Enum
+from typing import Optional, Any, Dict, List, Union
+
+
+class PortType(Enum):
+    TEXT = "text"
+    NUMBER = "number"
+    CHECKBOX = "checkbox"
+    SELECT = "select"
+    RADIO = "radio"
+    TEXTAREA = "textarea"
+    INPUT = "input"
+    FILE = "file"
+    LIST = "list"
+    COLOR = "color"
+    TEMPERATURE = "temperature"
+
+
+class Port:
+    def __init__(
+        self,
+        name: str,
+        port_type: Union[PortType, str],
+        required: bool = True,
+        show: bool = False,
+        value: Any = None,
+        options: Optional[List[Any]] = None,
+        field_type: Optional[str] = None,
+        is_output: bool = False,
+        condition: Optional[str] = None,
+        max_length: Optional[int] = None,
+        support_file_types: Optional[List[str]] = None,
+        multiple: Optional[bool] = None,
+        group: Optional[str] = None,
+        group_collpased: bool = False,
+        has_tooltip: bool = False,
+        max: Optional[Union[int, float]] = None,
+        min: Optional[Union[int, float]] = None,
+        max_count: Optional[int] = None,
+        list: bool = False,
+    ) -> None:
+        self.name = name
+        self.port_type = port_type
+        self.required = required
+        self.show = show
+        self.value = value
+        self.options = options
+        self.field_type = field_type
+        self.is_output = is_output
+        self.condition = condition
+        self.max_length = max_length
+        self.support_file_types = support_file_types
+        self.multiple = multiple
+        self.group = group
+        self.group_collpased = group_collpased
+        self.has_tooltip = has_tooltip
+        self.max = max
+        self.min = min
+        self.max_count = max_count
+        self.list = list
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "display_name": self.name,
+            "field_type": self.port_type.value if isinstance(self.port_type, PortType) else self.port_type,
+            "required": self.required,
+            "show": self.show,
+            "value": self.value,
+            "options": self.options,
+            "type": self.field_type,
+            "is_output": self.is_output,
+            # "condition": f"(fieldsData) => {{ {self.condition} }}" if self.condition else "",
+            "max_length": self.max_length,
+            "support_file_types": ", ".join(self.support_file_types) if self.support_file_types else None,
+            "multiple": self.multiple,
+            "group": self.group,
+            "group_collpased": self.group_collpased,
+            "has_tooltip": self.has_tooltip,
+            "max": self.max,
+            "min": self.min,
+            "list": self.list,
+        }
+
+
+class InputPort(Port):
+    def __init__(
+        self,
+        name: str,
+        port_type: Union[PortType, str],
+        required: bool = True,
+        show: bool = False,
+        value: Any = None,
+        options: Optional[List[Any]] = None,
+        field_type: Optional[str] = None,
+        condition: Optional[str] = None,
+        max_length: Optional[int] = None,
+        support_file_types: Optional[List[str]] = None,
+        multiple: Optional[bool] = None,
+        group: Optional[str] = None,
+        group_collpased: bool = False,
+        has_tooltip: bool = False,
+        max: Optional[Union[int, float]] = None,
+        min: Optional[Union[int, float]] = None,
+        max_count: Optional[int] = None,
+        list: bool = False,
+    ) -> None:
+        super().__init__(
+            name=name,
+            port_type=port_type,
+            required=required,
+            show=show,
+            value=value,
+            options=options,
+            field_type=field_type,
+            is_output=False,
+            condition=condition,
+            max_length=max_length,
+            support_file_types=support_file_types,
+            multiple=multiple,
+            group=group,
+            group_collpased=group_collpased,
+            has_tooltip=has_tooltip,
+            max=max,
+            min=min,
+            max_count=max_count,
+            list=list,
+        )
+
+
+class OutputPort(Port):
+    def __init__(
+        self,
+        name: str = "output",
+        port_type: Union[PortType, str] = PortType.TEXT,
+        required: bool = True,
+        show: bool = False,
+        value: Any = None,
+        options: Optional[List[Any]] = None,
+        field_type: Optional[str] = None,
+        condition: Optional[str] = None,
+        max_length: Optional[int] = None,
+        support_file_types: Optional[List[str]] = None,
+        multiple: Optional[bool] = None,
+        group: Optional[str] = None,
+        group_collpased: bool = False,
+        has_tooltip: bool = False,
+        max: Optional[Union[int, float]] = None,
+        min: Optional[Union[int, float]] = None,
+        max_count: Optional[int] = None,
+        list: bool = False,
+    ) -> None:
+        super().__init__(
+            name=name,
+            port_type=port_type,
+            required=required,
+            show=show,
+            value=value,
+            options=options,
+            field_type=field_type,
+            is_output=True,
+            condition=condition,
+            max_length=max_length,
+            support_file_types=support_file_types,
+            multiple=multiple,
+            group=group,
+            group_collpased=group_collpased,
+            has_tooltip=has_tooltip,
+            max=max,
+            min=min,
+            max_count=max_count,
+            list=list,
+        )

vectorvein/workflow/graph/workflow.py

@@ -0,0 +1,87 @@
+import json
+from typing import List, Union
+
+from .node import Node
+from .edge import Edge
+
+
+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,
+    ):
+        if isinstance(source_node, Node):
+            source_node_id = source_node.id
+        else:
+            source_node_id = source_node
+        if isinstance(target_node, Node):
+            target_node_id = target_node.id
+        else:
+            target_node_id = target_node
+
+        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.sourceHandle} → {edge.targetHandle}"
+            lines.append(f"    {source_label} -->|{label}| {target_label}")
+
+        return "\n".join(lines)

vectorvein/workflow/nodes/__init__.py

@@ -0,0 +1,136 @@
+from .audio_generation import MinimaxMusicGeneration, SoundEffects, Tts
+from .control_flows import Conditional, Empty, HumanFeedback, JsonProcess, RandomChoice
+from .file_processing import FileLoader, FileUpload
+from .image_generation import BackgroundGeneration, DallE, Flux1, Inpainting, Kolors, Pulid, Recraft, StableDiffusion
+from .llms import (
+    AliyunQwen,
+    BaiduWenxin,
+    ChatGLM,
+    Claude,
+    Deepseek,
+    Gemini,
+    LingYiWanWu,
+    MiniMax,
+    Moonshot,
+    OpenAI,
+    XAi,
+)
+from .media_editing import (
+    AudioEditing,
+    ImageBackgroundRemoval,
+    ImageEditing,
+    ImageSegmentation,
+    ImageWatermark,
+    VideoEditing,
+    VideoScreenshot,
+)
+from .media_processing import (
+    ClaudeVision,
+    DeepseekVl,
+    GeminiVision,
+    GlmVision,
+    GptVision,
+    InternVision,
+    Ocr,
+    QwenVision,
+    SpeechRecognition,
+)
+from .output import Audio, Text, Table, Document, Echarts, Email, Html, Mermaid, Mindmap, PictureRender
+from .relational_db import GetTableInfo, RunSql, SmartQuery
+from .text_processing import (
+    TextInOut,
+    TextReplace,
+    TextSplitters,
+    TextTruncation,
+    MarkdownToHtml,
+    ListRender,
+    TemplateCompose,
+)
+from .tools import CodebaseAnalysis, TextTranslation, TextSearch, ProgrammingFunction, ImageSearch, WorkflowInvoke
+from .vector_db import VectorDbAddData, VectorDbDeleteData, VectorDbSearchData
+from .video_generation import KlingVideo, CogVideoX
+from .web_crawlers import TextCrawler, BilibiliCrawler, DouyinCrawler, YoutubeCrawler
+
+
+__all__ = [
+    "AliyunQwen",
+    "Audio",
+    "AudioEditing",
+    "BackgroundGeneration",
+    "BaiduWenxin",
+    "BilibiliCrawler",
+    "ChatGLM",
+    "Claude",
+    "ClaudeVision",
+    "CodebaseAnalysis",
+    "CogVideoX",
+    "Conditional",
+    "DallE",
+    "Deepseek",
+    "DeepseekVl",
+    "Document",
+    "DouyinCrawler",
+    "Echarts",
+    "Email",
+    "Empty",
+    "FileLoader",
+    "FileUpload",
+    "Flux1",
+    "Gemini",
+    "GeminiVision",
+    "GetTableInfo",
+    "GlmVision",
+    "GptVision",
+    "Html",
+    "HumanFeedback",
+    "ImageBackgroundRemoval",
+    "ImageEditing",
+    "ImageSearch",
+    "ImageSegmentation",
+    "ImageWatermark",
+    "Inpainting",
+    "InternVision",
+    "JsonProcess",
+    "KlingVideo",
+    "Kolors",
+    "LingYiWanWu",
+    "ListRender",
+    "MarkdownToHtml",
+    "Mermaid",
+    "Mindmap",
+    "MiniMax",
+    "MinimaxMusicGeneration",
+    "Moonshot",
+    "Ocr",
+    "OpenAI",
+    "PictureRender",
+    "ProgrammingFunction",
+    "Pulid",
+    "QwenVision",
+    "RandomChoice",
+    "Recraft",
+    "RunSql",
+    "SmartQuery",
+    "SoundEffects",
+    "SpeechRecognition",
+    "StableDiffusion",
+    "Table",
+    "TemplateCompose",
+    "Text",
+    "TextCrawler",
+    "TextInOut",
+    "TextReplace",
+    "TextSearch",
+    "TextSplitters",
+    "TextTranslation",
+    "TextTruncation",
+    "Tts",
+    "VectorDbAddData",
+    "VectorDbDeleteData",
+    "VectorDbSearchData",
+    "VideoEditing",
+    "VideoScreenshot",
+    "WorkflowInvoke",
+    "XAi",
+    "YoutubeCrawler",
+]

vectorvein/workflow/nodes/audio_generation.py

@@ -0,0 +1,154 @@
+from typing import Optional
+
+from ..graph.node import Node
+from ..graph.port import PortType, InputPort, OutputPort
+
+
+class MinimaxMusicGeneration(Node):
+    def __init__(self, id: Optional[str] = None):
+        super().__init__(
+            node_type="MinimaxMusicGeneration",
+            category="audio_generation",
+            task_name="audio_generation.minimax_music_generation",
+            node_id=id,
+            ports={
+                "audio_file": InputPort(
+                    name="audio_file",
+                    port_type=PortType.FILE,
+                    value=list(),
+                    support_file_types=[".wav", ".mp3"],
+                ),
+                "purpose": InputPort(
+                    name="purpose",
+                    port_type=PortType.SELECT,
+                    value="song",
+                    options=[
+                        {"value": "song", "label": "song"},
+                        {"value": "voice", "label": "voice"},
+                        {"value": "instrumental", "label": "instrumental"},
+                    ],
+                ),
+                "lyrics": InputPort(
+                    name="lyrics",
+                    port_type=PortType.TEXTAREA,
+                    value="",
+                    max_length=200,
+                ),
+                "model": InputPort(
+                    name="model",
+                    port_type=PortType.SELECT,
+                    value="music-01",
+                    options=[{"value": "music-01", "label": "music-01"}],
+                ),
+                "sample_rate": InputPort(
+                    name="sample_rate",
+                    port_type=PortType.SELECT,
+                    value=44100,
+                    options=[
+                        {"value": 16000, "label": "16000"},
+                        {"value": 24000, "label": "24000"},
+                        {"value": 32000, "label": "32000"},
+                        {"value": 44100, "label": "44100"},
+                    ],
+                ),
+                "bitrate": InputPort(
+                    name="bitrate",
+                    port_type=PortType.SELECT,
+                    value=256000,
+                    options=[
+                        {"value": 32000, "label": "32000"},
+                        {"value": 64000, "label": "64000"},
+                        {"value": 128000, "label": "128000"},
+                        {"value": 256000, "label": "256000"},
+                    ],
+                ),
+                "format": InputPort(
+                    name="format",
+                    port_type=PortType.SELECT,
+                    value="mp3",
+                    options=[
+                        {"value": "mp3", "label": "mp3"},
+                        {"value": "wav", "label": "wav"},
+                        {"value": "pcm", "label": "pcm"},
+                    ],
+                ),
+                "output_type": OutputPort(
+                    name="output_type",
+                    port_type=PortType.SELECT,
+                    value="only_link",
+                    options=[
+                        {"value": "only_link", "label": "only_link"},
+                        {"value": "html", "label": "html"},
+                    ],
+                ),
+                "output": OutputPort(),
+            },
+        )
+
+
+class SoundEffects(Node):
+    def __init__(self, id: Optional[str] = None):
+        super().__init__(
+            node_type="SoundEffects",
+            category="audio_generation",
+            task_name="audio_generation.sound_effects",
+            node_id=id,
+            ports={
+                "text": InputPort(
+                    name="text",
+                    port_type=PortType.TEXTAREA,
+                    value="",
+                    max_length=50,
+                ),
+                "video": InputPort(
+                    name="video",
+                    port_type=PortType.FILE,
+                    value=list(),
+                    support_file_types=[".mp4", ".mov", ".webm", ".m4v", ".gif"],
+                ),
+                "length": InputPort(
+                    name="length",
+                    port_type=PortType.NUMBER,
+                    value=5,
+                    min=1,
+                    max=60,
+                ),
+                "output_type": OutputPort(
+                    name="output_type",
+                    port_type=PortType.SELECT,
+                    value="only_link",
+                    options=[
+                        {"value": "only_link", "label": "only_link"},
+                        {"value": "html", "label": "html"},
+                    ],
+                ),
+                "output": OutputPort(),
+            },
+        )
+
+
+class Tts(Node):
+    def __init__(self, id: Optional[str] = None):
+        super().__init__(
+            node_type="Tts",
+            category="audio_generation",
+            task_name="audio_generation.tts",
+            node_id=id,
+            ports={
+                "text": InputPort(
+                    name="text",
+                    port_type=PortType.TEXTAREA,
+                    value="",
+                ),
+                "output_type": OutputPort(
+                    name="output_type",
+                    port_type=PortType.SELECT,
+                    value="only_link",
+                    options=[
+                        {"value": "only_link", "label": "only_link"},
+                        {"value": "html", "label": "html"},
+                    ],
+                ),
+                "output": OutputPort(),
+            },
+        )