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

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

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel
+
+from .workflow_types import WorkflowStatus
+
+
+class WorkflowRunData(BaseModel):
+    id: str | None = None
+    workflow_id: str | None = None
+    status: WorkflowStatus | None = None
+    outputs: dict[str, Any] | None = None
+    error: str | None = None
+    elapsed_time: float | None = None
+    total_tokens: int | None = None
+    total_steps: int | None = None
+    created_at: int | None = None
+    finished_at: int | None = None
+
+    @staticmethod
+    def builder() -> WorkflowRunDataBuilder:
+        return WorkflowRunDataBuilder()
+
+
+class WorkflowRunDataBuilder:
+    def __init__(self):
+        self._workflow_run_data = WorkflowRunData()
+
+    def build(self) -> WorkflowRunData:
+        return self._workflow_run_data
+
+    def id(self, id: str) -> WorkflowRunDataBuilder:
+        self._workflow_run_data.id = id
+        return self
+
+    def workflow_id(self, workflow_id: str) -> WorkflowRunDataBuilder:
+        self._workflow_run_data.workflow_id = workflow_id
+        return self
+
+    def status(self, status: WorkflowStatus) -> WorkflowRunDataBuilder:
+        self._workflow_run_data.status = status
+        return self
+
+    def outputs(self, outputs: dict[str, Any]) -> WorkflowRunDataBuilder:
+        self._workflow_run_data.outputs = outputs
+        return self
+
+    def error(self, error: str) -> WorkflowRunDataBuilder:
+        self._workflow_run_data.error = error
+        return self
+
+    def elapsed_time(self, elapsed_time: float) -> WorkflowRunDataBuilder:
+        self._workflow_run_data.elapsed_time = elapsed_time
+        return self
+
+    def total_tokens(self, total_tokens: int) -> WorkflowRunDataBuilder:
+        self._workflow_run_data.total_tokens = total_tokens
+        return self
+
+    def total_steps(self, total_steps: int) -> WorkflowRunDataBuilder:
+        self._workflow_run_data.total_steps = total_steps
+        return self
+
+    def created_at(self, created_at: int) -> WorkflowRunDataBuilder:
+        self._workflow_run_data.created_at = created_at
+        return self
+
+    def finished_at(self, finished_at: int) -> WorkflowRunDataBuilder:
+        self._workflow_run_data.finished_at = finished_at
+        return self

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

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .workflow_run_data import WorkflowRunData
+
+
+class WorkflowRunInfo(BaseModel):
+    workflow_run_id: str | None = None
+    task_id: str | None = None
+    data: WorkflowRunData | None = None
+
+    @staticmethod
+    def builder() -> WorkflowRunInfoBuilder:
+        return WorkflowRunInfoBuilder()
+
+
+class WorkflowRunInfoBuilder:
+    def __init__(self):
+        self._workflow_run_info = WorkflowRunInfo()
+
+    def build(self) -> WorkflowRunInfo:
+        return self._workflow_run_info
+
+    def workflow_run_id(self, workflow_run_id: str) -> WorkflowRunInfoBuilder:
+        self._workflow_run_info.workflow_run_id = workflow_run_id
+        return self
+
+    def task_id(self, task_id: str) -> WorkflowRunInfoBuilder:
+        self._workflow_run_info.task_id = task_id
+        return self
+
+    def data(self, data: WorkflowRunData) -> WorkflowRunInfoBuilder:
+        self._workflow_run_info.data = data
+        return self

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

@@ -0,0 +1,54 @@
+from typing import Literal
+
+# Response mode types
+ResponseMode = Literal["streaming", "blocking"]
+
+# File types
+FileType = Literal["document", "image", "audio", "video", "custom"]
+
+# Transfer method types
+TransferMethod = Literal["remote_url", "local_file"]
+
+# Workflow status types
+WorkflowStatus = Literal["running", "succeeded", "failed", "stopped"]
+
+# Event types
+EventType = Literal[
+    "workflow_started",
+    "node_started",
+    "text_chunk",
+    "node_finished",
+    "workflow_finished",
+    "tts_message",
+    "tts_message_end",
+    "ping",
+]
+
+# Node types
+NodeType = Literal[
+    "start",
+    "end",
+    "llm",
+    "code",
+    "template",
+    "knowledge_retrieval",
+    "question_classifier",
+    "if_else",
+    "variable_assigner",
+    "parameter_extractor",
+]
+
+# Icon types
+IconType = Literal["emoji", "image"]
+
+# App mode types
+AppMode = Literal["workflow"]
+
+# Log status types
+LogStatus = Literal["succeeded", "failed", "stopped"]
+
+# Created by role types
+CreatedByRole = Literal["end_user", "account"]
+
+# Created from types
+CreatedFrom = Literal["service-api", "web-app"]

dify_oapi/api/workflow/v1/resource/__init__.py

@@ -1 +0,0 @@
-from .workflow import *  # noqa 403

dify_oapi/api/workflow/v1/resource/file.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+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.file.preview_file_request import PreviewFileRequest
+from ..model.file.preview_file_response import PreviewFileResponse
+from ..model.file.upload_file_request import UploadFileRequest
+from ..model.file.upload_file_response import UploadFileResponse
+
+
+class File:
+    def __init__(self, config: Config) -> None:
+        self.config = config
+
+    def upload_file(self, request: UploadFileRequest, request_option: RequestOption) -> UploadFileResponse:
+        """Upload file for multimodal support.
+
+        Args:
+            request: The upload file request
+            request_option: Request options including API key
+
+        Returns:
+            UploadFileResponse with file information
+        """
+        return Transport.execute(self.config, request, unmarshal_as=UploadFileResponse, option=request_option)
+
+    async def aupload_file(self, request: UploadFileRequest, request_option: RequestOption) -> UploadFileResponse:
+        """Upload file for multimodal support asynchronously.
+
+        Args:
+            request: The upload file request
+            request_option: Request options including API key
+
+        Returns:
+            UploadFileResponse with file information
+        """
+        return await ATransport.aexecute(self.config, request, unmarshal_as=UploadFileResponse, option=request_option)
+
+    def preview_file(self, request: PreviewFileRequest, request_option: RequestOption) -> PreviewFileResponse:
+        """Preview or download uploaded file.
+
+        Args:
+            request: The preview file request
+            request_option: Request options including API key
+
+        Returns:
+            PreviewFileResponse with file content
+        """
+        return Transport.execute(self.config, request, unmarshal_as=PreviewFileResponse, option=request_option)
+
+    async def apreview_file(self, request: PreviewFileRequest, request_option: RequestOption) -> PreviewFileResponse:
+        """Preview or download uploaded file asynchronously.
+
+        Args:
+            request: The preview file request
+            request_option: Request options including API key
+
+        Returns:
+            PreviewFileResponse with file content
+        """
+        return await ATransport.aexecute(self.config, request, unmarshal_as=PreviewFileResponse, option=request_option)

dify_oapi/api/workflow/v1/resource/info.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+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.info.get_info_request import GetInfoRequest
+from ..model.info.get_info_response import GetInfoResponse
+from ..model.info.get_parameters_request import GetParametersRequest
+from ..model.info.get_parameters_response import GetParametersResponse
+from ..model.info.get_site_request import GetSiteRequest
+from ..model.info.get_site_response import GetSiteResponse
+
+
+class Info:
+    def __init__(self, config: Config) -> None:
+        self.config = config
+
+    def get_info(self, request: GetInfoRequest, request_option: RequestOption) -> GetInfoResponse:
+        """Get application basic information.
+
+        Args:
+            request: The get info request
+            request_option: Request options including API key
+
+        Returns:
+            GetInfoResponse with application information
+        """
+        return Transport.execute(self.config, request, unmarshal_as=GetInfoResponse, option=request_option)
+
+    async def aget_info(self, request: GetInfoRequest, request_option: RequestOption) -> GetInfoResponse:
+        """Get application basic information asynchronously.
+
+        Args:
+            request: The get info request
+            request_option: Request options including API key
+
+        Returns:
+            GetInfoResponse with application information
+        """
+        return await ATransport.aexecute(self.config, request, unmarshal_as=GetInfoResponse, option=request_option)
+
+    def get_parameters(self, request: GetParametersRequest, request_option: RequestOption) -> GetParametersResponse:
+        """Get application parameters.
+
+        Args:
+            request: The get parameters request
+            request_option: Request options including API key
+
+        Returns:
+            GetParametersResponse with application parameters
+        """
+        return Transport.execute(self.config, request, unmarshal_as=GetParametersResponse, option=request_option)
+
+    async def aget_parameters(
+        self, request: GetParametersRequest, request_option: RequestOption
+    ) -> GetParametersResponse:
+        """Get application parameters asynchronously.
+
+        Args:
+            request: The get parameters request
+            request_option: Request options including API key
+
+        Returns:
+            GetParametersResponse with application parameters
+        """
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetParametersResponse, option=request_option
+        )
+
+    def get_site(self, request: GetSiteRequest, request_option: RequestOption) -> GetSiteResponse:
+        """Get WebApp settings.
+
+        Args:
+            request: The get site request
+            request_option: Request options including API key
+
+        Returns:
+            GetSiteResponse with WebApp settings
+        """
+        return Transport.execute(self.config, request, unmarshal_as=GetSiteResponse, option=request_option)
+
+    async def aget_site(self, request: GetSiteRequest, request_option: RequestOption) -> GetSiteResponse:
+        """Get WebApp settings asynchronously.
+
+        Args:
+            request: The get site request
+            request_option: Request options including API key
+
+        Returns:
+            GetSiteResponse with WebApp settings
+        """
+        return await ATransport.aexecute(self.config, request, unmarshal_as=GetSiteResponse, option=request_option)

dify_oapi/api/workflow/v1/resource/log.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+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.log.get_workflow_logs_request import GetWorkflowLogsRequest
+from ..model.log.get_workflow_logs_response import GetWorkflowLogsResponse
+
+
+class Log:
+    def __init__(self, config: Config) -> None:
+        self.config = config
+
+    def get_workflow_logs(
+        self, request: GetWorkflowLogsRequest, request_option: RequestOption
+    ) -> GetWorkflowLogsResponse:
+        """Get workflow execution logs.
+
+        Args:
+            request: The get workflow logs request
+            request_option: Request options including API key
+
+        Returns:
+            GetWorkflowLogsResponse with workflow logs
+        """
+        return Transport.execute(self.config, request, unmarshal_as=GetWorkflowLogsResponse, option=request_option)
+
+    async def aget_workflow_logs(
+        self, request: GetWorkflowLogsRequest, request_option: RequestOption
+    ) -> GetWorkflowLogsResponse:
+        """Get workflow execution logs asynchronously.
+
+        Args:
+            request: The get workflow logs request
+            request_option: Request options including API key
+
+        Returns:
+            GetWorkflowLogsResponse with workflow logs
+        """
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetWorkflowLogsResponse, option=request_option
+        )

dify_oapi/api/workflow/v1/resource/workflow.py

@@ -5,98 +5,216 @@ 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_workflow_log_request import GetWorkflowLogRequest
-from ..model.get_workflow_log_response import GetWorkflowLogResponse
-from ..model.get_workflow_result_request import GetWorkflowResultRequest
-from ..model.get_workflow_result_response import GetWorkflowResultResponse
-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.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
 
 
 class Workflow:
     def __init__(self, config: Config) -> None:
-        self.config: Config = config
+        self.config = config
 
     @overload
-    def run(
+    def run_workflow(
         self,
         request: RunWorkflowRequest,
-        option: RequestOption | None,
+        request_option: RequestOption,
         stream: Literal[True],
     ) -> Generator[bytes, None, None]: ...
 
     @overload
-    def run(
+    def run_workflow(
         self,
         request: RunWorkflowRequest,
-        option: RequestOption | None,
-        stream: Literal[False],
+        request_option: RequestOption,
+        stream: Literal[False] = False,
     ) -> RunWorkflowResponse: ...
 
-    @overload
-    def run(self, request: RunWorkflowRequest, option: RequestOption | None) -> RunWorkflowResponse: ...
-
-    def run(
+    def run_workflow(
         self,
         request: RunWorkflowRequest,
-        option: RequestOption | None = None,
+        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, option=option, stream=True)
-        else:
-            return Transport.execute(self.config, request, unmarshal_as=RunWorkflowResponse, option=option)
+            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(
+    async def arun_workflow(
         self,
         request: RunWorkflowRequest,
-        option: RequestOption | None,
+        request_option: RequestOption,
         stream: Literal[True],
     ) -> AsyncGenerator[bytes, None]: ...
 
     @overload
-    async def arun(
+    async def arun_workflow(
         self,
         request: RunWorkflowRequest,
-        option: RequestOption | None,
-        stream: Literal[False],
+        request_option: RequestOption,
+        stream: Literal[False] = False,
     ) -> RunWorkflowResponse: ...
 
-    @overload
-    async def arun(self, request: RunWorkflowRequest, option: RequestOption | None) -> RunWorkflowResponse: ...
-
-    async def arun(
+    async def arun_workflow(
         self,
         request: RunWorkflowRequest,
-        option: RequestOption | None = None,
+        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, option=option, stream=True)
-        else:
-            return await ATransport.aexecute(self.config, request, unmarshal_as=RunWorkflowResponse, option=option)
+            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 stop(self, request: StopWorkflowRequest, option: RequestOption | None = None) -> StopWorkflowResponse:
-        return Transport.execute(self.config, request, unmarshal_as=StopWorkflowResponse, option=option)
+    def run_specific_workflow(
+        self,
+        request: RunSpecificWorkflowRequest,
+        request_option: RequestOption,
+        stream: bool = False,
+    ) -> RunSpecificWorkflowResponse | Generator[bytes, None, None]:
+        """Execute specific version workflow.
 
-    async def astop(self, request: StopWorkflowRequest, option: RequestOption | None = None) -> StopWorkflowResponse:
-        return await ATransport.aexecute(self.config, request, unmarshal_as=StopWorkflowResponse, option=option)
+        Args:
+            request: The run specific workflow request
+            request_option: Request options including API key
+            stream: Whether to use streaming mode
 
-    def result(
-        self, request: GetWorkflowResultRequest, option: RequestOption | None = None
-    ) -> GetWorkflowResultResponse:
-        return Transport.execute(self.config, request, unmarshal_as=GetWorkflowResultResponse, option=option)
+        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)
 
-    async def aresult(
-        self, request: GetWorkflowResultRequest, option: RequestOption | None = None
-    ) -> GetWorkflowResultResponse:
-        return await ATransport.aexecute(self.config, request, unmarshal_as=GetWorkflowResultResponse, option=option)
+    @overload
+    async def arun_specific_workflow(
+        self,
+        request: RunSpecificWorkflowRequest,
+        request_option: RequestOption,
+        stream: Literal[True],
+    ) -> AsyncGenerator[bytes, None]: ...
 
-    def log(self, request: GetWorkflowLogRequest, option: RequestOption | None = None) -> GetWorkflowLogResponse:
-        return Transport.execute(self.config, request, unmarshal_as=GetWorkflowLogResponse, option=option)
+    @overload
+    async def arun_specific_workflow(
+        self,
+        request: RunSpecificWorkflowRequest,
+        request_option: RequestOption,
+        stream: Literal[False] = False,
+    ) -> RunSpecificWorkflowResponse: ...
 
-    async def alog(self, request: GetWorkflowLogRequest, option: RequestOption | None = None) -> GetWorkflowLogResponse:
-        return await ATransport.aexecute(self.config, request, unmarshal_as=GetWorkflowLogResponse, option=option)
+    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
+
+        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)
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=RunSpecificWorkflowResponse, option=request_option
+        )
+
+    def get_workflow_run_detail(
+        self, request: GetWorkflowRunDetailRequest, request_option: RequestOption
+    ) -> GetWorkflowRunDetailResponse:
+        """Get workflow execution details.
+
+        Args:
+            request: The get workflow run detail request
+            request_option: Request options including API key
+
+        Returns:
+            GetWorkflowRunDetailResponse with workflow execution details
+        """
+        return Transport.execute(self.config, request, unmarshal_as=GetWorkflowRunDetailResponse, option=request_option)
+
+    async def aget_workflow_run_detail(
+        self, request: GetWorkflowRunDetailRequest, request_option: RequestOption
+    ) -> GetWorkflowRunDetailResponse:
+        """Get workflow execution details asynchronously.
+
+        Args:
+            request: The get workflow run detail request
+            request_option: Request options including API key
+
+        Returns:
+            GetWorkflowRunDetailResponse with workflow execution details
+        """
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetWorkflowRunDetailResponse, option=request_option
+        )
+
+    def stop_workflow(self, request: StopWorkflowRequest, request_option: RequestOption) -> StopWorkflowResponse:
+        """Stop workflow execution.
+
+        Args:
+            request: The stop workflow request
+            request_option: Request options including API key
+
+        Returns:
+            StopWorkflowResponse with stop result
+        """
+        return Transport.execute(self.config, request, unmarshal_as=StopWorkflowResponse, option=request_option)
+
+    async def astop_workflow(self, request: StopWorkflowRequest, request_option: RequestOption) -> StopWorkflowResponse:
+        """Stop workflow execution asynchronously.
+
+        Args:
+            request: The stop workflow request
+            request_option: Request options including API key
+
+        Returns:
+            StopWorkflowResponse with stop result
+        """
+        return await ATransport.aexecute(self.config, request, unmarshal_as=StopWorkflowResponse, option=request_option)

dify_oapi/api/workflow/v1/version.py

@@ -1,8 +1,14 @@
 from dify_oapi.core.model.config import Config
 
-from .resource import Workflow
+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)

{dify_oapi2-0.2.0.dist-info → dify_oapi2-0.3.0.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.3
 Name: dify-oapi2
-Version: 0.2.0
+Version: 0.3.0
 Summary: A package for interacting with the Dify Service-API
 License: MIT
 Keywords: dify,nlp,ai,language-processing
 Author: Oscaner Miao
-Author-email: oscaner1997@163.com
+Author-email: oscaner1997@gmail.com
 Requires-Python: >=3.10
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3