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

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/api/workflow/v1/resource/workflow.py

@@ -5,12 +5,6 @@ from dify_oapi.core.http.transport import ATransport, Transport
 from dify_oapi.core.model.config import Config
 from dify_oapi.core.model.request_option import RequestOption
 
-from ..model.get_info_request import GetInfoRequest
-from ..model.get_info_response import GetInfoResponse
-from ..model.get_parameters_request import GetParametersRequest
-from ..model.get_parameters_response import GetParametersResponse
-from ..model.get_site_request import GetSiteRequest
-from ..model.get_site_response import GetSiteResponse
 from ..model.get_workflow_logs_request import GetWorkflowLogsRequest
 from ..model.get_workflow_logs_response import GetWorkflowLogsResponse
 from ..model.get_workflow_run_detail_request import GetWorkflowRunDetailRequest
@@ -19,8 +13,6 @@ from ..model.run_workflow_request import RunWorkflowRequest
 from ..model.run_workflow_response import RunWorkflowResponse
 from ..model.stop_workflow_request import StopWorkflowRequest
 from ..model.stop_workflow_response import StopWorkflowResponse
-from ..model.upload_file_request import UploadFileRequest
-from ..model.upload_file_response import UploadFileResponse
 
 
 class Workflow:
@@ -97,12 +89,6 @@ class Workflow:
     async def astop(self, request: StopWorkflowRequest, request_option: RequestOption) -> StopWorkflowResponse:
         return await ATransport.aexecute(self.config, request, unmarshal_as=StopWorkflowResponse, option=request_option)
 
-    def upload(self, request: UploadFileRequest, request_option: RequestOption) -> UploadFileResponse:
-        return Transport.execute(self.config, request, unmarshal_as=UploadFileResponse, option=request_option)
-
-    async def aupload(self, request: UploadFileRequest, request_option: RequestOption) -> UploadFileResponse:
-        return await ATransport.aexecute(self.config, request, unmarshal_as=UploadFileResponse, option=request_option)
-
     def logs(self, request: GetWorkflowLogsRequest, request_option: RequestOption) -> GetWorkflowLogsResponse:
         return Transport.execute(self.config, request, unmarshal_as=GetWorkflowLogsResponse, option=request_option)
 
@@ -110,23 +96,3 @@ class Workflow:
         return await ATransport.aexecute(
             self.config, request, unmarshal_as=GetWorkflowLogsResponse, option=request_option
         )
-
-    def info(self, request: GetInfoRequest, request_option: RequestOption) -> GetInfoResponse:
-        return Transport.execute(self.config, request, unmarshal_as=GetInfoResponse, option=request_option)
-
-    async def ainfo(self, request: GetInfoRequest, request_option: RequestOption) -> GetInfoResponse:
-        return await ATransport.aexecute(self.config, request, unmarshal_as=GetInfoResponse, option=request_option)
-
-    def parameters(self, request: GetParametersRequest, request_option: RequestOption) -> GetParametersResponse:
-        return Transport.execute(self.config, request, unmarshal_as=GetParametersResponse, option=request_option)
-
-    async def aparameters(self, request: GetParametersRequest, request_option: RequestOption) -> GetParametersResponse:
-        return await ATransport.aexecute(
-            self.config, request, unmarshal_as=GetParametersResponse, option=request_option
-        )
-
-    def site(self, request: GetSiteRequest, request_option: RequestOption) -> GetSiteResponse:
-        return Transport.execute(self.config, request, unmarshal_as=GetSiteResponse, option=request_option)
-
-    async def asite(self, request: GetSiteRequest, request_option: RequestOption) -> GetSiteResponse:
-        return await ATransport.aexecute(self.config, request, unmarshal_as=GetSiteResponse, option=request_option)

dify_oapi/api/workflow/v1/version.py

@@ -1,3 +1,7 @@
+from dify_oapi.api.dify.v1.resource.audio import Audio
+from dify_oapi.api.dify.v1.resource.feedback import Feedback
+from dify_oapi.api.dify.v1.resource.file import File
+from dify_oapi.api.dify.v1.resource.info import Info
 from dify_oapi.core.model.config import Config
 
 from .resource.workflow import Workflow
@@ -6,3 +10,8 @@ from .resource.workflow import Workflow
 class V1:
     def __init__(self, config: Config):
         self.workflow = Workflow(config)
+        # System APIs - delegate to dify module
+        self.file = File(config)
+        self.audio = Audio(config)
+        self.info = Info(config)
+        self.feedback = Feedback(config)

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.knowledge.service import KnowledgeService
 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,10 +20,11 @@ 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
-        self._knowledge: Knowledge | None = None
+        self._knowledge: KnowledgeService | None = None
 
     @property
     def chat(self) -> ChatService:
@@ -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:
@@ -46,7 +57,7 @@ class Client:
         return self._workflow
 
     @property
-    def knowledge(self) -> Knowledge:
+    def knowledge(self) -> KnowledgeService:
         if self._knowledge is None:
             raise RuntimeError("Knowledge base service has not been initialized")
         return self._knowledge
@@ -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,10 +131,11 @@ 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)
-        client._knowledge = Knowledge(self._config)
+        client._knowledge = KnowledgeService(self._config)
         return client
 
     def _init_logger(self):

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"]