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

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

@@ -0,0 +1,69 @@
+"""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 for workflow execution
+ResponseMode = Literal["streaming", "blocking"]
+
+# File types supported in workflow inputs
+FileType = Literal["document", "image", "audio", "video", "custom"]
+
+# File transfer methods
+TransferMethod = Literal["remote_url", "local_file"]
+
+# Workflow execution status
+WorkflowStatus = Literal["running", "succeeded", "failed", "stopped"]
+
+# Node execution status
+NodeStatus = Literal["running", "succeeded", "failed", "stopped"]
+
+# Streaming event types
+EventType = Literal[
+    "workflow_started",
+    "node_started",
+    "text_chunk",
+    "node_finished",
+    "workflow_finished",
+    "tts_message",
+    "tts_message_end",
+    "ping",
+]
+
+# Workflow node types
+NodeType = Literal[
+    "start",
+    "end",
+    "llm",
+    "code",
+    "template",
+    "knowledge_retrieval",
+    "question_classifier",
+    "if_else",
+    "variable_assigner",
+    "parameter_extractor",
+]
+
+# WebApp icon types
+IconType = Literal["emoji", "image"]
+
+# Application mode types
+AppMode = Literal["workflow"]
+
+# Log status filter types (includes "running" for filtering)
+LogStatus = Literal["succeeded", "failed", "stopped", "running"]
+
+# Creator role types
+CreatedByRole = Literal["end_user", "account"]
+
+# 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,14 +5,22 @@ 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.workflow.get_workflow_run_detail_request import GetWorkflowRunDetailRequest
-from ..model.workflow.get_workflow_run_detail_response import GetWorkflowRunDetailResponse
-from ..model.workflow.run_specific_workflow_request import RunSpecificWorkflowRequest
-from ..model.workflow.run_specific_workflow_response import RunSpecificWorkflowResponse
-from ..model.workflow.run_workflow_request import RunWorkflowRequest
-from ..model.workflow.run_workflow_response import RunWorkflowResponse
-from ..model.workflow.stop_workflow_request import StopWorkflowRequest
-from ..model.workflow.stop_workflow_response import StopWorkflowResponse
+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
+from ..model.get_workflow_run_detail_response import GetWorkflowRunDetailResponse
+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:
@@ -20,7 +28,7 @@ class Workflow:
         self.config = config
 
     @overload
-    def run_workflow(
+    def run(
         self,
         request: RunWorkflowRequest,
         request_option: RequestOption,
@@ -28,35 +36,25 @@ class Workflow:
     ) -> Generator[bytes, None, None]: ...
 
     @overload
-    def run_workflow(
+    def run(
         self,
         request: RunWorkflowRequest,
         request_option: RequestOption,
         stream: Literal[False] = False,
     ) -> RunWorkflowResponse: ...
 
-    def run_workflow(
+    def run(
         self,
         request: RunWorkflowRequest,
         request_option: RequestOption,
         stream: bool = False,
     ) -> RunWorkflowResponse | Generator[bytes, None, None]:
-        """Execute workflow.
-
-        Args:
-            request: The run workflow request
-            request_option: Request options including API key
-            stream: Whether to use streaming mode
-
-        Returns:
-            RunWorkflowResponse for blocking mode or Generator[bytes, None, None] for streaming mode
-        """
         if stream:
             return Transport.execute(self.config, request, stream=True, option=request_option)
         return Transport.execute(self.config, request, unmarshal_as=RunWorkflowResponse, option=request_option)
 
     @overload
-    async def arun_workflow(
+    async def arun(
         self,
         request: RunWorkflowRequest,
         request_option: RequestOption,
@@ -64,157 +62,71 @@ class Workflow:
     ) -> AsyncGenerator[bytes, None]: ...
 
     @overload
-    async def arun_workflow(
+    async def arun(
         self,
         request: RunWorkflowRequest,
         request_option: RequestOption,
         stream: Literal[False] = False,
     ) -> RunWorkflowResponse: ...
 
-    async def arun_workflow(
+    async def arun(
         self,
         request: RunWorkflowRequest,
         request_option: RequestOption,
         stream: bool = False,
     ) -> RunWorkflowResponse | AsyncGenerator[bytes, None]:
-        """Execute workflow asynchronously.
-
-        Args:
-            request: The run workflow request
-            request_option: Request options including API key
-            stream: Whether to use streaming mode
-
-        Returns:
-            RunWorkflowResponse for blocking mode or AsyncGenerator[bytes, None] for streaming mode
-        """
         if stream:
             return await ATransport.aexecute(self.config, request, stream=True, option=request_option)
         return await ATransport.aexecute(self.config, request, unmarshal_as=RunWorkflowResponse, option=request_option)
 
-    @overload
-    def run_specific_workflow(
-        self,
-        request: RunSpecificWorkflowRequest,
-        request_option: RequestOption,
-        stream: Literal[True],
-    ) -> Generator[bytes, None, None]: ...
-
-    @overload
-    def run_specific_workflow(
-        self,
-        request: RunSpecificWorkflowRequest,
-        request_option: RequestOption,
-        stream: Literal[False] = False,
-    ) -> RunSpecificWorkflowResponse: ...
-
-    def run_specific_workflow(
-        self,
-        request: RunSpecificWorkflowRequest,
-        request_option: RequestOption,
-        stream: bool = False,
-    ) -> RunSpecificWorkflowResponse | Generator[bytes, None, None]:
-        """Execute specific version workflow.
-
-        Args:
-            request: The run specific workflow request
-            request_option: Request options including API key
-            stream: Whether to use streaming mode
-
-        Returns:
-            RunSpecificWorkflowResponse for blocking mode or Generator[bytes, None, None] for streaming mode
-        """
-        if stream:
-            return Transport.execute(self.config, request, stream=True, option=request_option)
-        return Transport.execute(self.config, request, unmarshal_as=RunSpecificWorkflowResponse, option=request_option)
-
-    @overload
-    async def arun_specific_workflow(
-        self,
-        request: RunSpecificWorkflowRequest,
-        request_option: RequestOption,
-        stream: Literal[True],
-    ) -> AsyncGenerator[bytes, None]: ...
-
-    @overload
-    async def arun_specific_workflow(
-        self,
-        request: RunSpecificWorkflowRequest,
-        request_option: RequestOption,
-        stream: Literal[False] = False,
-    ) -> RunSpecificWorkflowResponse: ...
-
-    async def arun_specific_workflow(
-        self,
-        request: RunSpecificWorkflowRequest,
-        request_option: RequestOption,
-        stream: bool = False,
-    ) -> RunSpecificWorkflowResponse | AsyncGenerator[bytes, None]:
-        """Execute specific version workflow asynchronously.
-
-        Args:
-            request: The run specific workflow request
-            request_option: Request options including API key
-            stream: Whether to use streaming mode
+    def detail(
+        self, request: GetWorkflowRunDetailRequest, request_option: RequestOption
+    ) -> GetWorkflowRunDetailResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetWorkflowRunDetailResponse, option=request_option)
 
-        Returns:
-            RunSpecificWorkflowResponse for blocking mode or AsyncGenerator[bytes, None] for streaming mode
-        """
-        if stream:
-            return await ATransport.aexecute(self.config, request, stream=True, option=request_option)
+    async def adetail(
+        self, request: GetWorkflowRunDetailRequest, request_option: RequestOption
+    ) -> GetWorkflowRunDetailResponse:
         return await ATransport.aexecute(
-            self.config, request, unmarshal_as=RunSpecificWorkflowResponse, option=request_option
+            self.config, request, unmarshal_as=GetWorkflowRunDetailResponse, option=request_option
         )
 
-    def get_workflow_run_detail(
-        self, request: GetWorkflowRunDetailRequest, request_option: RequestOption
-    ) -> GetWorkflowRunDetailResponse:
-        """Get workflow execution details.
+    def stop(self, request: StopWorkflowRequest, request_option: RequestOption) -> StopWorkflowResponse:
+        return Transport.execute(self.config, request, unmarshal_as=StopWorkflowResponse, option=request_option)
 
-        Args:
-            request: The get workflow run detail request
-            request_option: Request options including API key
+    async def astop(self, request: StopWorkflowRequest, request_option: RequestOption) -> StopWorkflowResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=StopWorkflowResponse, option=request_option)
 
-        Returns:
-            GetWorkflowRunDetailResponse with workflow execution details
-        """
-        return Transport.execute(self.config, request, unmarshal_as=GetWorkflowRunDetailResponse, 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 aget_workflow_run_detail(
-        self, request: GetWorkflowRunDetailRequest, request_option: RequestOption
-    ) -> GetWorkflowRunDetailResponse:
-        """Get workflow execution details asynchronously.
+    async def aupload(self, request: UploadFileRequest, request_option: RequestOption) -> UploadFileResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=UploadFileResponse, option=request_option)
 
-        Args:
-            request: The get workflow run detail request
-            request_option: Request options including API key
+    def logs(self, request: GetWorkflowLogsRequest, request_option: RequestOption) -> GetWorkflowLogsResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetWorkflowLogsResponse, option=request_option)
 
-        Returns:
-            GetWorkflowRunDetailResponse with workflow execution details
-        """
+    async def alogs(self, request: GetWorkflowLogsRequest, request_option: RequestOption) -> GetWorkflowLogsResponse:
         return await ATransport.aexecute(
-            self.config, request, unmarshal_as=GetWorkflowRunDetailResponse, option=request_option
+            self.config, request, unmarshal_as=GetWorkflowLogsResponse, option=request_option
         )
 
-    def stop_workflow(self, request: StopWorkflowRequest, request_option: RequestOption) -> StopWorkflowResponse:
-        """Stop workflow execution.
+    def info(self, request: GetInfoRequest, request_option: RequestOption) -> GetInfoResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetInfoResponse, option=request_option)
 
-        Args:
-            request: The stop workflow request
-            request_option: Request options including API key
+    async def ainfo(self, request: GetInfoRequest, request_option: RequestOption) -> GetInfoResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=GetInfoResponse, option=request_option)
 
-        Returns:
-            StopWorkflowResponse with stop result
-        """
-        return Transport.execute(self.config, request, unmarshal_as=StopWorkflowResponse, 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 astop_workflow(self, request: StopWorkflowRequest, request_option: RequestOption) -> StopWorkflowResponse:
-        """Stop workflow execution asynchronously.
+    async def aparameters(self, request: GetParametersRequest, request_option: RequestOption) -> GetParametersResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetParametersResponse, option=request_option
+        )
 
-        Args:
-            request: The stop workflow request
-            request_option: Request options including API key
+    def site(self, request: GetSiteRequest, request_option: RequestOption) -> GetSiteResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetSiteResponse, option=request_option)
 
-        Returns:
-            StopWorkflowResponse with stop result
-        """
-        return await ATransport.aexecute(self.config, request, unmarshal_as=StopWorkflowResponse, 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,14 +1,8 @@
 from dify_oapi.core.model.config import Config
 
-from .resource.file import File
-from .resource.info import Info
-from .resource.log import Log
 from .resource.workflow import Workflow
 
 
 class V1:
     def __init__(self, config: Config):
-        self.workflow: Workflow = Workflow(config)
-        self.file: File = File(config)
-        self.log: Log = Log(config)
-        self.info: Info = Info(config)
+        self.workflow = Workflow(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_base.service import KnowledgeBaseService
+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,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_base: KnowledgeBaseService | None = None
+        self._knowledge: Knowledge | 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,10 +57,10 @@ class Client:
         return self._workflow
 
     @property
-    def knowledge_base(self) -> KnowledgeBaseService:
-        if self._knowledge_base is None:
+    def knowledge(self) -> Knowledge:
+        if self._knowledge is None:
             raise RuntimeError("Knowledge base service has not been initialized")
-        return self._knowledge_base
+        return self._knowledge
 
     def request(self, request: BaseRequest):
         if self._config 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,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_base = KnowledgeBaseService(self._config)
+        client._knowledge = Knowledge(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"]

dify_oapi/core/http/transport/async_transport.py

@@ -16,6 +16,7 @@ from dify_oapi.core.model.request_option import RequestOption
 from dify_oapi.core.type import T
 
 from ._misc import _build_header, _build_url, _get_sleep_time, _merge_dicts, _unmarshaller
+from .connection_pool import connection_pool
 
 
 def _format_log_details(
@@ -33,6 +34,12 @@ def _format_log_details(
     return ", ".join(details)
 
 
+def _update_response_mode(body_data: dict | None, stream: bool) -> None:
+    """Update response_mode field in request body based on stream parameter"""
+    if body_data and "response_mode" in body_data:
+        body_data["response_mode"] = "streaming" if stream else "blocking"
+
+
 async def _handle_async_stream_error(response: httpx.Response) -> bytes:
     """Handle async streaming response errors"""
     try:
@@ -58,6 +65,16 @@ async def _async_stream_generator(
     method_name = http_method.name
     body_data = _merge_dicts(json_, files, data)
 
+    # Use connection pool for async streaming requests
+    client = connection_pool.get_async_client(
+        conf.domain or "",
+        conf.timeout,
+        getattr(conf, "max_keepalive_connections", 20),
+        getattr(conf, "max_connections", 100),
+        getattr(conf, "keepalive_expiry", 30.0),
+        getattr(conf, "verify_ssl", True),
+    )
+
     for retry in range(conf.max_retry_count + 1):
         if retry > 0:
             sleep_time = _get_sleep_time(retry)
@@ -65,19 +82,16 @@ async def _async_stream_generator(
             await asyncio.sleep(sleep_time)
 
         try:
-            async with (
-                httpx.AsyncClient() as client,
-                client.stream(
-                    method_name,
-                    url,
-                    headers=headers,
-                    params=tuple(req.queries),
-                    json=json_,
-                    data=data,
-                    files=files,
-                    timeout=conf.timeout,
-                ) as response,
-            ):
+            async with client.stream(
+                method_name,
+                url,
+                headers=headers,
+                params=tuple(req.queries),
+                json=json_,
+                data=data,
+                files=files,
+                timeout=conf.timeout,
+            ) as response:
                 logger.debug(
                     f"{_format_log_details(method_name, url, headers, req.queries, body_data)}, stream response"
                 )
@@ -162,8 +176,10 @@ class ATransport:
             files = req.files
             if req.body is not None:
                 data = json.loads(JSON.marshal(req.body))
+                _update_response_mode(data, stream)
         elif req.body is not None:
             json_ = json.loads(JSON.marshal(req.body))
+            _update_response_mode(json_, stream)
 
         if stream:
             return _async_stream_generator(
@@ -173,45 +189,52 @@ class ATransport:
         method_name = req.http_method.name
         body_data = _merge_dicts(json_, files, data)
 
-        async with httpx.AsyncClient() as client:
-            for retry in range(conf.max_retry_count + 1):
-                if retry > 0:
-                    sleep_time = _get_sleep_time(retry)
-                    logger.info(f"in-request: sleep {sleep_time}s")
-                    await asyncio.sleep(sleep_time)
+        # Use connection pool for async regular requests
+        client = connection_pool.get_async_client(
+            conf.domain or "",
+            conf.timeout,
+            getattr(conf, "max_keepalive_connections", 20),
+            getattr(conf, "max_connections", 100),
+            getattr(conf, "keepalive_expiry", 30.0),
+            getattr(conf, "verify_ssl", True),
+        )
+
+        for retry in range(conf.max_retry_count + 1):
+            if retry > 0:
+                sleep_time = _get_sleep_time(retry)
+                logger.info(f"in-request: sleep {sleep_time}s")
+                await asyncio.sleep(sleep_time)
+
+            try:
+                response = await client.request(
+                    method_name,
+                    url,
+                    headers=headers,
+                    params=tuple(req.queries),
+                    json=json_,
+                    data=data,
+                    files=files,
+                    timeout=conf.timeout,
+                )
+                break
+            except httpx.RequestError as e:
+                err_msg = f"{e.__class__.__name__}: {e!r}"
+                log_details = _format_log_details(method_name, url, headers, req.queries, body_data)
 
-                try:
-                    response = await client.request(
-                        method_name,
-                        url,
-                        headers=headers,
-                        params=tuple(req.queries),
-                        json=json_,
-                        data=data,
-                        files=files,
-                        timeout=conf.timeout,
-                    )
-                    break
-                except httpx.RequestError as e:
-                    err_msg = f"{e.__class__.__name__}: {e!r}"
-                    log_details = _format_log_details(method_name, url, headers, req.queries, body_data)
-
-                    if retry < conf.max_retry_count:
-                        logger.info(
-                            f"in-request: retrying ({retry + 1}/{conf.max_retry_count}) {log_details}, exp: {err_msg}"
-                        )
-                        continue
+                if retry < conf.max_retry_count:
                     logger.info(
-                        f"in-request: request failed, retried ({retry}/{conf.max_retry_count}) {log_details}, exp: {err_msg}"
+                        f"in-request: retrying ({retry + 1}/{conf.max_retry_count}) {log_details}, exp: {err_msg}"
                     )
-                    raise
+                    continue
+                logger.info(
+                    f"in-request: request failed, retried ({retry}/{conf.max_retry_count}) {log_details}, exp: {err_msg}"
+                )
+                raise
 
-            logger.debug(
-                f"{_format_log_details(method_name, url, headers, req.queries, body_data)} {response.status_code}"
-            )
+        logger.debug(f"{_format_log_details(method_name, url, headers, req.queries, body_data)} {response.status_code}")
 
-            raw_resp = RawResponse()
-            raw_resp.status_code = response.status_code
-            raw_resp.headers = dict(response.headers)
-            raw_resp.content = response.content
-            return _unmarshaller(raw_resp, unmarshal_as)
+        raw_resp = RawResponse()
+        raw_resp.status_code = response.status_code
+        raw_resp.headers = dict(response.headers)
+        raw_resp.content = response.content
+        return _unmarshaller(raw_resp, unmarshal_as)