dify-oapi2 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

dify_oapi/api/workflow/v1/model/node_started_data.py

@@ -0,0 +1,81 @@
+"""Node started event data model.
+
+This module defines the data structure for node_started streaming events.
+"""
+
+from typing import Any, Optional
+
+from pydantic import BaseModel
+
+from .workflow_types import NodeType
+
+
+class NodeStartedData(BaseModel):
+    """Data structure for node_started streaming event."""
+
+    id: str
+    node_id: str
+    node_type: NodeType
+    title: str
+    index: int
+    predecessor_node_id: Optional[str] = None
+    inputs: dict[str, Any]
+    created_at: int
+
+    @staticmethod
+    def builder() -> "NodeStartedDataBuilder":
+        """Create a new NodeStartedData builder."""
+        return NodeStartedDataBuilder()
+
+
+class NodeStartedDataBuilder:
+    """Builder for NodeStartedData."""
+
+    def __init__(self):
+        self._node_started_data = NodeStartedData(
+            id="", node_id="", node_type="start", title="", index=0, inputs={}, created_at=0
+        )
+
+    def build(self) -> NodeStartedData:
+        """Build the NodeStartedData instance."""
+        return self._node_started_data
+
+    def id(self, id: str) -> "NodeStartedDataBuilder":
+        """Set the node execution ID."""
+        self._node_started_data.id = id
+        return self
+
+    def node_id(self, node_id: str) -> "NodeStartedDataBuilder":
+        """Set the node ID."""
+        self._node_started_data.node_id = node_id
+        return self
+
+    def node_type(self, node_type: NodeType) -> "NodeStartedDataBuilder":
+        """Set the node type."""
+        self._node_started_data.node_type = node_type
+        return self
+
+    def title(self, title: str) -> "NodeStartedDataBuilder":
+        """Set the node title."""
+        self._node_started_data.title = title
+        return self
+
+    def index(self, index: int) -> "NodeStartedDataBuilder":
+        """Set the node index."""
+        self._node_started_data.index = index
+        return self
+
+    def predecessor_node_id(self, predecessor_node_id: str) -> "NodeStartedDataBuilder":
+        """Set the predecessor node ID."""
+        self._node_started_data.predecessor_node_id = predecessor_node_id
+        return self
+
+    def inputs(self, inputs: dict[str, Any]) -> "NodeStartedDataBuilder":
+        """Set the node inputs."""
+        self._node_started_data.inputs = inputs
+        return self
+
+    def created_at(self, created_at: int) -> "NodeStartedDataBuilder":
+        """Set the creation timestamp."""
+        self._node_started_data.created_at = created_at
+        return self

dify_oapi/api/workflow/v1/model/ping_data.py

@@ -0,0 +1,28 @@
+"""Ping event data model.
+
+This module defines the data structure for ping streaming events.
+"""
+
+from pydantic import BaseModel
+
+
+class PingData(BaseModel):
+    """Data structure for ping streaming event (empty data)."""
+
+    pass
+
+    @staticmethod
+    def builder() -> "PingDataBuilder":
+        """Create a new PingData builder."""
+        return PingDataBuilder()
+
+
+class PingDataBuilder:
+    """Builder for PingData."""
+
+    def __init__(self):
+        self._ping_data = PingData()
+
+    def build(self) -> PingData:
+        """Build the PingData instance."""
+        return self._ping_data

dify_oapi/api/workflow/v1/model/run_workflow_request_body.py

@@ -9,7 +9,7 @@ from .workflow_types import ResponseMode
 
 class RunWorkflowRequestBody(BaseModel):
     inputs: WorkflowInputs | None = None
-    response_mode: ResponseMode | None = None
+    response_mode: ResponseMode | None = "streaming"
     user: str | None = None
     files: list[WorkflowFileInfo] | None = None
     trace_id: str | None = None

dify_oapi/api/workflow/v1/model/text_chunk_data.py

@@ -0,0 +1,39 @@
+"""Text chunk event data model.
+
+This module defines the data structure for text_chunk streaming events.
+"""
+
+from pydantic import BaseModel
+
+
+class TextChunkData(BaseModel):
+    """Data structure for text_chunk streaming event."""
+
+    text: str
+    from_variable_selector: list[str]
+
+    @staticmethod
+    def builder() -> "TextChunkDataBuilder":
+        """Create a new TextChunkData builder."""
+        return TextChunkDataBuilder()
+
+
+class TextChunkDataBuilder:
+    """Builder for TextChunkData."""
+
+    def __init__(self):
+        self._text_chunk_data = TextChunkData(text="", from_variable_selector=[])
+
+    def build(self) -> TextChunkData:
+        """Build the TextChunkData instance."""
+        return self._text_chunk_data
+
+    def text(self, text: str) -> "TextChunkDataBuilder":
+        """Set the text chunk."""
+        self._text_chunk_data.text = text
+        return self
+
+    def from_variable_selector(self, from_variable_selector: list[str]) -> "TextChunkDataBuilder":
+        """Set the variable selector path."""
+        self._text_chunk_data.from_variable_selector = from_variable_selector
+        return self

dify_oapi/api/workflow/v1/model/tts_message_data.py

@@ -0,0 +1,45 @@
+"""TTS message event data model.
+
+This module defines the data structure for tts_message streaming events.
+"""
+
+from pydantic import BaseModel
+
+
+class TtsMessageData(BaseModel):
+    """Data structure for tts_message streaming event."""
+
+    message_id: str
+    audio: str  # Base64 encoded audio data
+    created_at: int
+
+    @staticmethod
+    def builder() -> "TtsMessageDataBuilder":
+        """Create a new TtsMessageData builder."""
+        return TtsMessageDataBuilder()
+
+
+class TtsMessageDataBuilder:
+    """Builder for TtsMessageData."""
+
+    def __init__(self):
+        self._tts_message_data = TtsMessageData(message_id="", audio="", created_at=0)
+
+    def build(self) -> TtsMessageData:
+        """Build the TtsMessageData instance."""
+        return self._tts_message_data
+
+    def message_id(self, message_id: str) -> "TtsMessageDataBuilder":
+        """Set the message ID."""
+        self._tts_message_data.message_id = message_id
+        return self
+
+    def audio(self, audio: str) -> "TtsMessageDataBuilder":
+        """Set the base64 encoded audio data."""
+        self._tts_message_data.audio = audio
+        return self
+
+    def created_at(self, created_at: int) -> "TtsMessageDataBuilder":
+        """Set the creation timestamp."""
+        self._tts_message_data.created_at = created_at
+        return self

dify_oapi/api/workflow/v1/model/tts_message_end_data.py

@@ -0,0 +1,45 @@
+"""TTS message end event data model.
+
+This module defines the data structure for tts_message_end streaming events.
+"""
+
+from pydantic import BaseModel
+
+
+class TtsMessageEndData(BaseModel):
+    """Data structure for tts_message_end streaming event."""
+
+    message_id: str
+    audio: str  # Empty string for end event
+    created_at: int
+
+    @staticmethod
+    def builder() -> "TtsMessageEndDataBuilder":
+        """Create a new TtsMessageEndData builder."""
+        return TtsMessageEndDataBuilder()
+
+
+class TtsMessageEndDataBuilder:
+    """Builder for TtsMessageEndData."""
+
+    def __init__(self):
+        self._tts_message_end_data = TtsMessageEndData(message_id="", audio="", created_at=0)
+
+    def build(self) -> TtsMessageEndData:
+        """Build the TtsMessageEndData instance."""
+        return self._tts_message_end_data
+
+    def message_id(self, message_id: str) -> "TtsMessageEndDataBuilder":
+        """Set the message ID."""
+        self._tts_message_end_data.message_id = message_id
+        return self
+
+    def audio(self, audio: str) -> "TtsMessageEndDataBuilder":
+        """Set the audio data (empty for end event)."""
+        self._tts_message_end_data.audio = audio
+        return self
+
+    def created_at(self, created_at: int) -> "TtsMessageEndDataBuilder":
+        """Set the creation timestamp."""
+        self._tts_message_end_data.created_at = created_at
+        return self

dify_oapi/api/workflow/v1/model/workflow_completion_response.py

@@ -0,0 +1,50 @@
+"""Workflow completion response for blocking mode.
+
+This module defines the WorkflowCompletionResponse model for handling
+workflow execution results in blocking mode.
+"""
+
+from pydantic import BaseModel
+
+from .workflow_run_data import WorkflowRunData
+
+
+class WorkflowCompletionResponse(BaseModel):
+    """Response structure for workflow execution in blocking mode."""
+
+    workflow_run_id: str
+    task_id: str
+    data: WorkflowRunData
+
+    @staticmethod
+    def builder() -> "WorkflowCompletionResponseBuilder":
+        """Create a new WorkflowCompletionResponse builder."""
+        return WorkflowCompletionResponseBuilder()
+
+
+class WorkflowCompletionResponseBuilder:
+    """Builder for WorkflowCompletionResponse."""
+
+    def __init__(self):
+        self._workflow_completion_response = WorkflowCompletionResponse(
+            workflow_run_id="", task_id="", data=WorkflowRunData()
+        )
+
+    def build(self) -> WorkflowCompletionResponse:
+        """Build the WorkflowCompletionResponse instance."""
+        return self._workflow_completion_response
+
+    def workflow_run_id(self, workflow_run_id: str) -> "WorkflowCompletionResponseBuilder":
+        """Set the workflow run ID."""
+        self._workflow_completion_response.workflow_run_id = workflow_run_id
+        return self
+
+    def task_id(self, task_id: str) -> "WorkflowCompletionResponseBuilder":
+        """Set the task ID."""
+        self._workflow_completion_response.task_id = task_id
+        return self
+
+    def data(self, data: WorkflowRunData) -> "WorkflowCompletionResponseBuilder":
+        """Set the workflow run data."""
+        self._workflow_completion_response.data = data
+        return self

dify_oapi/api/workflow/v1/model/workflow_finished_data.py

@@ -0,0 +1,93 @@
+"""Workflow finished event data model.
+
+This module defines the data structure for workflow_finished streaming events.
+"""
+
+from typing import Any, Optional
+
+from pydantic import BaseModel
+
+from .workflow_types import WorkflowStatus
+
+
+class WorkflowFinishedData(BaseModel):
+    """Data structure for workflow_finished streaming event."""
+
+    id: str
+    workflow_id: str
+    status: WorkflowStatus
+    outputs: Optional[dict[str, Any]] = None
+    error: Optional[str] = None
+    elapsed_time: Optional[float] = None
+    total_tokens: Optional[int] = None
+    total_steps: int
+    created_at: int
+    finished_at: int
+
+    @staticmethod
+    def builder() -> "WorkflowFinishedDataBuilder":
+        """Create a new WorkflowFinishedData builder."""
+        return WorkflowFinishedDataBuilder()
+
+
+class WorkflowFinishedDataBuilder:
+    """Builder for WorkflowFinishedData."""
+
+    def __init__(self):
+        self._workflow_finished_data = WorkflowFinishedData(
+            id="", workflow_id="", status="succeeded", total_steps=0, created_at=0, finished_at=0
+        )
+
+    def build(self) -> WorkflowFinishedData:
+        """Build the WorkflowFinishedData instance."""
+        return self._workflow_finished_data
+
+    def id(self, id: str) -> "WorkflowFinishedDataBuilder":
+        """Set the workflow run ID."""
+        self._workflow_finished_data.id = id
+        return self
+
+    def workflow_id(self, workflow_id: str) -> "WorkflowFinishedDataBuilder":
+        """Set the workflow ID."""
+        self._workflow_finished_data.workflow_id = workflow_id
+        return self
+
+    def status(self, status: WorkflowStatus) -> "WorkflowFinishedDataBuilder":
+        """Set the workflow status."""
+        self._workflow_finished_data.status = status
+        return self
+
+    def outputs(self, outputs: dict[str, Any]) -> "WorkflowFinishedDataBuilder":
+        """Set the workflow outputs."""
+        self._workflow_finished_data.outputs = outputs
+        return self
+
+    def error(self, error: str) -> "WorkflowFinishedDataBuilder":
+        """Set the error message."""
+        self._workflow_finished_data.error = error
+        return self
+
+    def elapsed_time(self, elapsed_time: float) -> "WorkflowFinishedDataBuilder":
+        """Set the elapsed time."""
+        self._workflow_finished_data.elapsed_time = elapsed_time
+        return self
+
+    def total_tokens(self, total_tokens: int) -> "WorkflowFinishedDataBuilder":
+        """Set the total tokens."""
+        self._workflow_finished_data.total_tokens = total_tokens
+        return self
+
+    def total_steps(self, total_steps: int) -> "WorkflowFinishedDataBuilder":
+        """Set the total steps."""
+        self._workflow_finished_data.total_steps = total_steps
+        return self
+
+    def created_at(self, created_at: int) -> "WorkflowFinishedDataBuilder":
+        """Set the creation timestamp."""
+        self._workflow_finished_data.created_at = created_at
+        return self
+
+    def finished_at(self, finished_at: int) -> "WorkflowFinishedDataBuilder":
+        """Set the finish timestamp."""
+        self._workflow_finished_data.finished_at = finished_at
+        return self

dify_oapi/api/workflow/v1/model/workflow_started_data.py

@@ -0,0 +1,51 @@
+"""Workflow started event data model.
+
+This module defines the data structure for workflow_started streaming events.
+"""
+
+from pydantic import BaseModel
+
+
+class WorkflowStartedData(BaseModel):
+    """Data structure for workflow_started streaming event."""
+
+    id: str
+    workflow_id: str
+    sequence_number: int
+    created_at: int
+
+    @staticmethod
+    def builder() -> "WorkflowStartedDataBuilder":
+        """Create a new WorkflowStartedData builder."""
+        return WorkflowStartedDataBuilder()
+
+
+class WorkflowStartedDataBuilder:
+    """Builder for WorkflowStartedData."""
+
+    def __init__(self):
+        self._workflow_started_data = WorkflowStartedData(id="", workflow_id="", sequence_number=0, created_at=0)
+
+    def build(self) -> WorkflowStartedData:
+        """Build the WorkflowStartedData instance."""
+        return self._workflow_started_data
+
+    def id(self, id: str) -> "WorkflowStartedDataBuilder":
+        """Set the workflow run ID."""
+        self._workflow_started_data.id = id
+        return self
+
+    def workflow_id(self, workflow_id: str) -> "WorkflowStartedDataBuilder":
+        """Set the workflow ID."""
+        self._workflow_started_data.workflow_id = workflow_id
+        return self
+
+    def sequence_number(self, sequence_number: int) -> "WorkflowStartedDataBuilder":
+        """Set the sequence number."""
+        self._workflow_started_data.sequence_number = sequence_number
+        return self
+
+    def created_at(self, created_at: int) -> "WorkflowStartedDataBuilder":
+        """Set the creation timestamp."""
+        self._workflow_started_data.created_at = created_at
+        return self

dify_oapi/api/workflow/v1/model/workflow_types.py

@@ -1,18 +1,27 @@
+"""Workflow API type definitions.
+
+This module contains all Literal type definitions for the Workflow API,
+ensuring strict type safety throughout the workflow module.
+"""
+
 from typing import Literal
 
-# Response mode types
+# Response mode types for workflow execution
 ResponseMode = Literal["streaming", "blocking"]
 
-# File types
+# File types supported in workflow inputs
 FileType = Literal["document", "image", "audio", "video", "custom"]
 
-# Transfer method types
+# File transfer methods
 TransferMethod = Literal["remote_url", "local_file"]
 
-# Workflow status types
+# Workflow execution status
 WorkflowStatus = Literal["running", "succeeded", "failed", "stopped"]
 
-# Event types
+# Node execution status
+NodeStatus = Literal["running", "succeeded", "failed", "stopped"]
+
+# Streaming event types
 EventType = Literal[
     "workflow_started",
     "node_started",
@@ -24,7 +33,7 @@ EventType = Literal[
     "ping",
 ]
 
-# Node types
+# Workflow node types
 NodeType = Literal[
     "start",
     "end",
@@ -38,17 +47,23 @@ NodeType = Literal[
     "parameter_extractor",
 ]
 
-# Icon types
+# WebApp icon types
 IconType = Literal["emoji", "image"]
 
-# App mode types
+# Application mode types
 AppMode = Literal["workflow"]
 
-# Log status types
-LogStatus = Literal["succeeded", "failed", "stopped"]
+# Log status filter types (includes "running" for filtering)
+LogStatus = Literal["succeeded", "failed", "stopped", "running"]
 
-# Created by role types
+# Creator role types
 CreatedByRole = Literal["end_user", "account"]
 
-# Created from types
+# Creation source types
 CreatedFrom = Literal["service-api", "web-app"]
+
+# User input form control types
+UserInputFormType = Literal["text-input", "paragraph", "select"]
+
+# UUID format validation pattern
+UUID_PATTERN = r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"

dify_oapi/client.py

@@ -1,12 +1,16 @@
 from __future__ import annotations
 
+import ssl
+
 from .api.chat.service import ChatService
+from .api.chatflow.service import ChatflowService
 from .api.completion.service import CompletionService
 from .api.dify.service import DifyService
 from .api.knowledge.service import Knowledge
 from .api.workflow.service import WorkflowService
 from .core.enum import LogLevel
 from .core.http.transport import Transport
+from .core.http.transport.connection_pool import connection_pool
 from .core.log import logger
 from .core.model.base_request import BaseRequest
 from .core.model.config import Config
@@ -16,6 +20,7 @@ class Client:
     def __init__(self):
         self._config: Config | None = None
         self._chat: ChatService | None = None
+        self._chatflow: ChatflowService | None = None
         self._completion: CompletionService | None = None
         self._dify: DifyService | None = None
         self._workflow: WorkflowService | None = None
@@ -27,6 +32,12 @@ class Client:
             raise RuntimeError("Chat service has not been initialized")
         return self._chat
 
+    @property
+    def chatflow(self) -> ChatflowService:
+        if self._chatflow is None:
+            raise RuntimeError("Chatflow service has not been initialized")
+        return self._chatflow
+
     @property
     def completion(self) -> CompletionService:
         if self._completion is None:
@@ -57,6 +68,14 @@ class Client:
         resp = Transport.execute(self._config, request)
         return resp
 
+    def close(self):
+        """Close all HTTP connections and clean up resources."""
+        connection_pool.close_all()
+
+    async def aclose(self):
+        """Async version of close for proper cleanup of async connections."""
+        await connection_pool.aclose_all()
+
     @staticmethod
     def builder() -> ClientBuilder:
         return ClientBuilder()
@@ -78,6 +97,31 @@ class ClientBuilder:
         self._config.max_retry_count = count
         return self
 
+    def max_keepalive_connections(self, count: int) -> ClientBuilder:
+        """Set maximum keepalive connections per connection pool."""
+        self._config.max_keepalive_connections = count
+        return self
+
+    def max_connections(self, count: int) -> ClientBuilder:
+        """Set maximum total connections per connection pool."""
+        self._config.max_connections = count
+        return self
+
+    def keepalive_expiry(self, seconds: float) -> ClientBuilder:
+        """Set keepalive connection expiry time in seconds."""
+        self._config.keepalive_expiry = seconds
+        return self
+
+    def timeout(self, seconds: float) -> ClientBuilder:
+        """Set client timeout in seconds."""
+        self._config.timeout = seconds
+        return self
+
+    def verify_ssl(self, verify: ssl.SSLContext | str | bool) -> ClientBuilder:
+        """Set SSL certificate verification."""
+        self._config.verify_ssl = verify
+        return self
+
     def build(self) -> Client:
         client: Client = Client()
         client._config = self._config
@@ -87,6 +131,7 @@ class ClientBuilder:
 
         # Initialize services
         client._chat = ChatService(self._config)
+        client._chatflow = ChatflowService(self._config)
         client._completion = CompletionService(self._config)
         client._dify = DifyService(self._config)
         client._workflow = WorkflowService(self._config)

dify_oapi/core/http/transport/__init__.py

@@ -1,4 +1,5 @@
 from .async_transport import ATransport
+from .connection_pool import ConnectionPoolManager, connection_pool
 from .sync_transport import Transport
 
-__all__ = ["Transport", "ATransport"]
+__all__ = ["Transport", "ATransport", "ConnectionPoolManager", "connection_pool"]