vectorvein 0.1.80__py3-none-any.whl → 0.1.82__py3-none-any.whl

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(),
+            },
+        )

vectorvein/workflow/nodes/control_flows.py

@@ -0,0 +1,170 @@
+from typing import Optional
+
+from ..graph.node import Node
+from ..graph.port import PortType, InputPort, OutputPort
+
+
+class Conditional(Node):
+    def __init__(self, id: Optional[str] = None):
+        super().__init__(
+            node_type="Conditional",
+            category="control_flows",
+            task_name="control_flows.conditional",
+            node_id=id,
+            ports={
+                "field_type": InputPort(
+                    name="field_type",
+                    port_type=PortType.SELECT,
+                    value="string",
+                    options=[
+                        {"value": "string", "label": "Str"},
+                        {"value": "number", "label": "Number"},
+                    ],
+                ),
+                "left_field": InputPort(
+                    name="left_field",
+                    port_type=PortType.INPUT,
+                    value="",
+                ),
+                "operator": InputPort(
+                    name="operator",
+                    port_type=PortType.SELECT,
+                    value="equal",
+                    options=[
+                        {"value": "equal", "label": "equal", "field_type": ["string", "number"]},
+                        {"value": "not_equal", "label": "not_equal", "field_type": ["string", "number"]},
+                        {"value": "greater_than", "label": "greater_than", "field_type": ["number"]},
+                        {"value": "less_than", "label": "less_than", "field_type": ["number"]},
+                        {"value": "greater_than_or_equal", "label": "greater_than_or_equal", "field_type": ["number"]},
+                        {"value": "less_than_or_equal", "label": "less_than_or_equal", "field_type": ["number"]},
+                        {"value": "include", "label": "include", "field_type": ["string"]},
+                        {"value": "not_include", "label": "not_include", "field_type": ["string"]},
+                        {"value": "is_empty", "label": "is_empty", "field_type": ["string"]},
+                        {"value": "is_not_empty", "label": "is_not_empty", "field_type": ["string"]},
+                        {"value": "starts_with", "label": "starts_with", "field_type": ["string"]},
+                        {"value": "ends_with", "label": "ends_with", "field_type": ["string"]},
+                    ],
+                ),
+                "right_field": InputPort(
+                    name="right_field",
+                    port_type=PortType.INPUT,
+                    value="",
+                ),
+                "true_output": InputPort(
+                    name="true_output",
+                    port_type=PortType.INPUT,
+                    value="",
+                ),
+                "false_output": InputPort(
+                    name="false_output",
+                    port_type=PortType.INPUT,
+                    value="",
+                ),
+                "output": OutputPort(),
+            },
+        )
+
+
+class Empty(Node):
+    def __init__(self, id: Optional[str] = None):
+        super().__init__(
+            node_type="Empty",
+            category="control_flows",
+            task_name="control_flows.empty",
+            node_id=id,
+            ports={
+                "input": InputPort(
+                    name="input",
+                    port_type=PortType.INPUT,
+                    value="",
+                ),
+                "output": OutputPort(),
+            },
+        )
+
+
+class HumanFeedback(Node):
+    def __init__(self, id: Optional[str] = None):
+        super().__init__(
+            node_type="HumanFeedback",
+            category="control_flows",
+            task_name="control_flows.human_feedback",
+            node_id=id,
+            ports={
+                "hint_message": InputPort(
+                    name="hint_message",
+                    port_type=PortType.TEXTAREA,
+                    value="",
+                ),
+                "human_input": InputPort(
+                    name="human_input",
+                    port_type=PortType.TEXTAREA,
+                    value="",
+                ),
+                "output": OutputPort(),
+            },
+        )
+
+
+class JsonProcess(Node):
+    def __init__(self, id: Optional[str] = None):
+        super().__init__(
+            node_type="JsonProcess",
+            category="control_flows",
+            task_name="control_flows.json_process",
+            node_id=id,
+            ports={
+                "input": InputPort(
+                    name="input",
+                    port_type=PortType.INPUT,
+                    value="",
+                ),
+                "process_mode": InputPort(
+                    name="process_mode",
+                    port_type=PortType.SELECT,
+                    value="get_value",
+                    options=[
+                        {"value": "get_value", "label": "get_value"},
+                        {"value": "get_multiple_values", "label": "get_multiple_values"},
+                        {"value": "list_values", "label": "list_values"},
+                        {"value": "list_keys", "label": "list_keys"},
+                    ],
+                ),
+                "key": InputPort(
+                    name="key",
+                    port_type=PortType.INPUT,
+                    value="",
+                    condition="return fieldsData.process_mode.value == 'get_value'",
+                ),
+                "keys": InputPort(
+                    name="keys",
+                    port_type=PortType.INPUT,
+                    value=list(),
+                ),
+                "default_value": InputPort(
+                    name="default_value",
+                    port_type=PortType.INPUT,
+                    value="",
+                    condition="return fieldsData.process_mode.value == 'get_value'",
+                ),
+                "output": OutputPort(),
+            },
+        )
+
+
+class RandomChoice(Node):
+    def __init__(self, id: Optional[str] = None):
+        super().__init__(
+            node_type="RandomChoice",
+            category="control_flows",
+            task_name="control_flows.random_choice",
+            node_id=id,
+            ports={
+                "input": InputPort(
+                    name="input",
+                    port_type=PortType.LIST,
+                    value=list(),
+                ),
+                "output": OutputPort(),
+            },
+        )

vectorvein/workflow/nodes/file_processing.py

@@ -0,0 +1,106 @@
+from typing import Optional
+
+from ..graph.node import Node
+from ..graph.port import PortType, InputPort, OutputPort
+
+
+class FileLoader(Node):
+    def __init__(self, id: Optional[str] = None):
+        super().__init__(
+            node_type="FileLoader",
+            category="file_processing",
+            task_name="file_processing.file_loader",
+            node_id=id,
+            ports={
+                "files": InputPort(
+                    name="files",
+                    port_type=PortType.FILE,
+                    value=list(),
+                    multiple=True,
+                ),
+                "parse_quality": InputPort(
+                    name="parse_quality",
+                    port_type=PortType.SELECT,
+                    value="default",
+                    options=[
+                        {"value": "default", "label": "default"},
+                        {"value": "high", "label": "high"},
+                    ],
+                ),
+                "remove_image": InputPort(
+                    name="remove_image",
+                    port_type=PortType.CHECKBOX,
+                    value=True,
+                    condition="return fieldsData.parse_quality.value === 'default'",
+                ),
+                "remove_url_and_email": InputPort(
+                    name="remove_url_and_email",
+                    port_type=PortType.CHECKBOX,
+                    value=True,
+                    condition="return fieldsData.parse_quality.value === 'default'",
+                ),
+                "parse_table": InputPort(
+                    name="parse_table",
+                    port_type=PortType.CHECKBOX,
+                    value=True,
+                    condition="return fieldsData.parse_quality.value === 'high'",
+                ),
+                "parse_formula": InputPort(
+                    name="parse_formula",
+                    port_type=PortType.CHECKBOX,
+                    value=False,
+                    condition="return fieldsData.parse_quality.value === 'high'",
+                ),
+                "multiple": InputPort(
+                    name="multiple",
+                    port_type=PortType.CHECKBOX,
+                    value=True,
+                ),
+                "output": OutputPort(),
+            },
+        )
+
+
+class FileUpload(Node):
+    def __init__(self, id: Optional[str] = None):
+        super().__init__(
+            node_type="FileUpload",
+            category="file_processing",
+            task_name="file_processing.file_upload",
+            node_id=id,
+            ports={
+                "files": InputPort(
+                    name="files",
+                    port_type=PortType.FILE,
+                    value=list(),
+                    support_file_types=["*/*"],
+                    multiple=True,
+                ),
+                "unzip_files": InputPort(
+                    name="unzip_files",
+                    port_type=PortType.CHECKBOX,
+                    value=False,
+                ),
+                "unzip_output_format": InputPort(
+                    name="unzip_output_format",
+                    port_type=PortType.SELECT,
+                    value="list",
+                    options=[
+                        {"value": "list", "label": "list"},
+                        {"value": "dict", "label": "dict"},
+                    ],
+                    condition="return fieldsData.unzip_files.value",
+                ),
+                "allowed_file_types": InputPort(
+                    name="allowed_file_types",
+                    port_type=PortType.INPUT,
+                    value="*/*",
+                ),
+                "multiple": InputPort(
+                    name="multiple",
+                    port_type=PortType.CHECKBOX,
+                    value=True,
+                ),
+                "output": OutputPort(),
+            },
+        )