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

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

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .run_specific_workflow_request_body import RunSpecificWorkflowRequestBody
+
+
+class RunSpecificWorkflowRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.workflow_id: str | None = None
+        self.request_body: RunSpecificWorkflowRequestBody | None = None
+
+    @staticmethod
+    def builder() -> RunSpecificWorkflowRequestBuilder:
+        return RunSpecificWorkflowRequestBuilder()
+
+
+class RunSpecificWorkflowRequestBuilder:
+    def __init__(self):
+        run_specific_workflow_request = RunSpecificWorkflowRequest()
+        run_specific_workflow_request.http_method = HttpMethod.POST
+        run_specific_workflow_request.uri = "/v1/workflows/:workflow_id/run"
+        self._run_specific_workflow_request = run_specific_workflow_request
+
+    def build(self) -> RunSpecificWorkflowRequest:
+        return self._run_specific_workflow_request
+
+    def workflow_id(self, workflow_id: str) -> RunSpecificWorkflowRequestBuilder:
+        self._run_specific_workflow_request.workflow_id = workflow_id
+        self._run_specific_workflow_request.paths["workflow_id"] = workflow_id
+        return self
+
+    def request_body(self, request_body: RunSpecificWorkflowRequestBody) -> RunSpecificWorkflowRequestBuilder:
+        self._run_specific_workflow_request.request_body = request_body
+        self._run_specific_workflow_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

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

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .workflow_file_info import WorkflowFileInfo
+from .workflow_inputs import WorkflowInputs
+from .workflow_types import ResponseMode
+
+
+class RunSpecificWorkflowRequestBody(BaseModel):
+    inputs: WorkflowInputs | None = None
+    response_mode: ResponseMode | None = None
+    user: str | None = None
+    files: list[WorkflowFileInfo] | None = None
+    trace_id: str | None = None
+
+    @staticmethod
+    def builder() -> RunSpecificWorkflowRequestBodyBuilder:
+        return RunSpecificWorkflowRequestBodyBuilder()
+
+
+class RunSpecificWorkflowRequestBodyBuilder:
+    def __init__(self):
+        self._run_specific_workflow_request_body = RunSpecificWorkflowRequestBody()
+
+    def build(self) -> RunSpecificWorkflowRequestBody:
+        return self._run_specific_workflow_request_body
+
+    def inputs(self, inputs: WorkflowInputs) -> RunSpecificWorkflowRequestBodyBuilder:
+        self._run_specific_workflow_request_body.inputs = inputs
+        return self
+
+    def response_mode(self, response_mode: ResponseMode) -> RunSpecificWorkflowRequestBodyBuilder:
+        self._run_specific_workflow_request_body.response_mode = response_mode
+        return self
+
+    def user(self, user: str) -> RunSpecificWorkflowRequestBodyBuilder:
+        self._run_specific_workflow_request_body.user = user
+        return self
+
+    def files(self, files: list[WorkflowFileInfo]) -> RunSpecificWorkflowRequestBodyBuilder:
+        self._run_specific_workflow_request_body.files = files
+        return self
+
+    def trace_id(self, trace_id: str) -> RunSpecificWorkflowRequestBodyBuilder:
+        self._run_specific_workflow_request_body.trace_id = trace_id
+        return self

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

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .workflow_run_info import WorkflowRunInfo
+
+
+class RunSpecificWorkflowResponse(WorkflowRunInfo, BaseResponse):
+    pass

dify_oapi/api/workflow/v1/model/{run_workflow_request.py → workflow/run_workflow_request.py}

@@ -21,12 +21,12 @@ class RunWorkflowRequestBuilder:
         run_workflow_request = RunWorkflowRequest()
         run_workflow_request.http_method = HttpMethod.POST
         run_workflow_request.uri = "/v1/workflows/run"
-        self._run_workflow_request: RunWorkflowRequest = run_workflow_request
+        self._run_workflow_request = run_workflow_request
+
+    def build(self) -> RunWorkflowRequest:
+        return self._run_workflow_request
 
     def request_body(self, request_body: RunWorkflowRequestBody) -> RunWorkflowRequestBuilder:
         self._run_workflow_request.request_body = request_body
         self._run_workflow_request.body = request_body.model_dump(exclude_none=True, mode="json")
         return self
-
-    def build(self) -> RunWorkflowRequest:
-        return self._run_workflow_request

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

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .workflow_file_info import WorkflowFileInfo
+from .workflow_inputs import WorkflowInputs
+from .workflow_types import ResponseMode
+
+
+class RunWorkflowRequestBody(BaseModel):
+    inputs: WorkflowInputs | None = None
+    response_mode: ResponseMode | None = None
+    user: str | None = None
+    files: list[WorkflowFileInfo] | None = None
+    trace_id: str | None = None
+
+    @staticmethod
+    def builder() -> RunWorkflowRequestBodyBuilder:
+        return RunWorkflowRequestBodyBuilder()
+
+
+class RunWorkflowRequestBodyBuilder:
+    def __init__(self) -> None:
+        self._run_workflow_request_body = RunWorkflowRequestBody()
+
+    def build(self) -> RunWorkflowRequestBody:
+        return self._run_workflow_request_body
+
+    def inputs(self, inputs: WorkflowInputs) -> RunWorkflowRequestBodyBuilder:
+        self._run_workflow_request_body.inputs = inputs
+        return self
+
+    def response_mode(self, response_mode: ResponseMode) -> RunWorkflowRequestBodyBuilder:
+        self._run_workflow_request_body.response_mode = response_mode
+        return self
+
+    def user(self, user: str) -> RunWorkflowRequestBodyBuilder:
+        self._run_workflow_request_body.user = user
+        return self
+
+    def files(self, files: list[WorkflowFileInfo]) -> RunWorkflowRequestBodyBuilder:
+        self._run_workflow_request_body.files = files
+        return self
+
+    def trace_id(self, trace_id: str) -> RunWorkflowRequestBodyBuilder:
+        self._run_workflow_request_body.trace_id = trace_id
+        return self

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

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .workflow_run_info import WorkflowRunInfo
+
+
+class RunWorkflowResponse(WorkflowRunInfo, BaseResponse):
+    pass

dify_oapi/api/workflow/v1/model/{stop_workflow_request.py → workflow/stop_workflow_request.py}

@@ -18,21 +18,21 @@ class StopWorkflowRequest(BaseRequest):
 
 
 class StopWorkflowRequestBuilder:
-    def __init__(self) -> None:
-        stop_Workflow_request = StopWorkflowRequest()
-        stop_Workflow_request.http_method = HttpMethod.POST
-        stop_Workflow_request.uri = "/v1/workflows/tasks/:task_id/stop"
-        self._stop_workflow_request: StopWorkflowRequest = stop_Workflow_request
+    def __init__(self):
+        stop_workflow_request = StopWorkflowRequest()
+        stop_workflow_request.http_method = HttpMethod.POST
+        stop_workflow_request.uri = "/v1/workflows/tasks/:task_id/stop"
+        self._stop_workflow_request = stop_workflow_request
+
+    def build(self) -> StopWorkflowRequest:
+        return self._stop_workflow_request
 
     def task_id(self, task_id: str) -> StopWorkflowRequestBuilder:
         self._stop_workflow_request.task_id = task_id
-        self._stop_workflow_request.paths["task_id"] = str(task_id)
+        self._stop_workflow_request.paths["task_id"] = task_id
         return self
 
     def request_body(self, request_body: StopWorkflowRequestBody) -> StopWorkflowRequestBuilder:
         self._stop_workflow_request.request_body = request_body
         self._stop_workflow_request.body = request_body.model_dump(exclude_none=True, mode="json")
         return self
-
-    def build(self) -> StopWorkflowRequest:
-        return self._stop_workflow_request

dify_oapi/api/workflow/v1/model/{stop_workflow_request_body.py → workflow/stop_workflow_request_body.py}

@@ -15,9 +15,9 @@ class StopWorkflowRequestBodyBuilder:
     def __init__(self):
         self._stop_workflow_request_body = StopWorkflowRequestBody()
 
+    def build(self) -> StopWorkflowRequestBody:
+        return self._stop_workflow_request_body
+
     def user(self, user: str) -> StopWorkflowRequestBodyBuilder:
         self._stop_workflow_request_body.user = user
         return self
-
-    def build(self) -> StopWorkflowRequestBody:
-        return self._stop_workflow_request_body

dify_oapi/api/workflow/v1/model/{stop_workflow_response.py → workflow/stop_workflow_response.py}

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from dify_oapi.core.model.base_response import BaseResponse
 
 

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

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel
+
+from .workflow_types import EventType
+
+
+class StreamingEvent(BaseModel):
+    event: EventType | None = None
+    task_id: str | None = None
+    workflow_run_id: str | None = None
+    data: dict[str, Any] | None = None
+
+    @staticmethod
+    def builder() -> StreamingEventBuilder:
+        return StreamingEventBuilder()
+
+
+class StreamingEventBuilder:
+    def __init__(self):
+        self._streaming_event = StreamingEvent()
+
+    def build(self) -> StreamingEvent:
+        return self._streaming_event
+
+    def event(self, event: EventType) -> StreamingEventBuilder:
+        self._streaming_event.event = event
+        return self
+
+    def task_id(self, task_id: str) -> StreamingEventBuilder:
+        self._streaming_event.task_id = task_id
+        return self
+
+    def workflow_run_id(self, workflow_run_id: str) -> StreamingEventBuilder:
+        self._streaming_event.workflow_run_id = workflow_run_id
+        return self
+
+    def data(self, data: dict[str, Any]) -> StreamingEventBuilder:
+        self._streaming_event.data = data
+        return self

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

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .workflow_types import FileType, TransferMethod
+
+
+class WorkflowFileInfo(BaseModel):
+    type: FileType | None = None
+    transfer_method: TransferMethod | None = None
+    url: str | None = None
+    upload_file_id: str | None = None
+
+    @staticmethod
+    def builder() -> WorkflowFileInfoBuilder:
+        return WorkflowFileInfoBuilder()
+
+
+class WorkflowFileInfoBuilder:
+    def __init__(self):
+        self._workflow_file_info = WorkflowFileInfo()
+
+    def build(self) -> WorkflowFileInfo:
+        return self._workflow_file_info
+
+    def type(self, type: FileType) -> WorkflowFileInfoBuilder:
+        self._workflow_file_info.type = type
+        return self
+
+    def transfer_method(self, transfer_method: TransferMethod) -> WorkflowFileInfoBuilder:
+        self._workflow_file_info.transfer_method = transfer_method
+        return self
+
+    def url(self, url: str) -> WorkflowFileInfoBuilder:
+        self._workflow_file_info.url = url
+        return self
+
+    def upload_file_id(self, upload_file_id: str) -> WorkflowFileInfoBuilder:
+        self._workflow_file_info.upload_file_id = upload_file_id
+        return self

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

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import Union
+
+from pydantic import BaseModel
+
+from .workflow_file_info import WorkflowFileInfo
+
+# Define specific types for workflow input values
+WorkflowInputValue = Union[
+    str,  # Text values
+    int,  # Integer values
+    float,  # Float values
+    bool,  # Boolean values
+    list[WorkflowFileInfo],  # File list type variables
+    list[str],  # String arrays
+    dict[str, Union[str, int, float, bool]],  # Object values
+]
+
+
+class WorkflowInputs(BaseModel):
+    # Dynamic inputs based on workflow configuration
+    # Can contain any key-value pairs defined by the workflow
+    inputs: dict[str, WorkflowInputValue] | None = None
+
+    @staticmethod
+    def builder() -> WorkflowInputsBuilder:
+        return WorkflowInputsBuilder()
+
+    def add_input(self, key: str, value: WorkflowInputValue) -> None:
+        if self.inputs is None:
+            self.inputs = {}
+        self.inputs[key] = value
+
+    def get_input(self, key: str) -> WorkflowInputValue | None:
+        if self.inputs is None:
+            return None
+        return self.inputs.get(key)
+
+
+class WorkflowInputsBuilder:
+    def __init__(self):
+        self._workflow_inputs = WorkflowInputs()
+
+    def build(self) -> WorkflowInputs:
+        return self._workflow_inputs
+
+    def inputs(self, inputs: dict[str, WorkflowInputValue]) -> WorkflowInputsBuilder:
+        self._workflow_inputs.inputs = inputs
+        return self
+
+    def add_input(self, key: str, value: WorkflowInputValue) -> WorkflowInputsBuilder:
+        if self._workflow_inputs.inputs is None:
+            self._workflow_inputs.inputs = {}
+        self._workflow_inputs.inputs[key] = value
+        return self

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)