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

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

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .workflow_types import AppMode
+
+
+class AppInfo(BaseModel):
+    name: str | None = None
+    description: str | None = None
+    tags: list[str] | None = None
+    mode: AppMode | None = None
+    author_name: str | None = None
+
+    @staticmethod
+    def builder() -> AppInfoBuilder:
+        return AppInfoBuilder()
+
+
+class AppInfoBuilder:
+    def __init__(self):
+        self._app_info = AppInfo()
+
+    def build(self) -> AppInfo:
+        return self._app_info
+
+    def name(self, name: str) -> AppInfoBuilder:
+        self._app_info.name = name
+        return self
+
+    def description(self, description: str) -> AppInfoBuilder:
+        self._app_info.description = description
+        return self
+
+    def tags(self, tags: list[str]) -> AppInfoBuilder:
+        self._app_info.tags = tags
+        return self
+
+    def mode(self, mode: AppMode) -> AppInfoBuilder:
+        self._app_info.mode = mode
+        return self
+
+    def author_name(self, author_name: str) -> AppInfoBuilder:
+        self._app_info.author_name = author_name
+        return self

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

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class EndUserInfo(BaseModel):
+    id: str | None = None
+    type: str | None = None
+    is_anonymous: bool | None = None
+    session_id: str | None = None
+
+    @staticmethod
+    def builder() -> EndUserInfoBuilder:
+        return EndUserInfoBuilder()
+
+
+class EndUserInfoBuilder:
+    def __init__(self):
+        self._end_user_info = EndUserInfo()
+
+    def build(self) -> EndUserInfo:
+        return self._end_user_info
+
+    def id(self, id: str) -> EndUserInfoBuilder:
+        self._end_user_info.id = id
+        return self
+
+    def type(self, type: str) -> EndUserInfoBuilder:
+        self._end_user_info.type = type
+        return self
+
+    def is_anonymous(self, is_anonymous: bool) -> EndUserInfoBuilder:
+        self._end_user_info.is_anonymous = is_anonymous
+        return self
+
+    def session_id(self, session_id: str) -> EndUserInfoBuilder:
+        self._end_user_info.session_id = session_id
+        return self

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

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class ExecutionMetadata(BaseModel):
+    total_tokens: int | None = None
+    total_price: float | None = None
+    currency: str | None = None
+
+    @staticmethod
+    def builder() -> ExecutionMetadataBuilder:
+        return ExecutionMetadataBuilder()
+
+
+class ExecutionMetadataBuilder:
+    def __init__(self):
+        self._execution_metadata = ExecutionMetadata()
+
+    def build(self) -> ExecutionMetadata:
+        return self._execution_metadata
+
+    def total_tokens(self, total_tokens: int) -> ExecutionMetadataBuilder:
+        self._execution_metadata.total_tokens = total_tokens
+        return self
+
+    def total_price(self, total_price: float) -> ExecutionMetadataBuilder:
+        self._execution_metadata.total_price = total_price
+        return self
+
+    def currency(self, currency: str) -> ExecutionMetadataBuilder:
+        self._execution_metadata.currency = currency
+        return self

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

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class FileUploadConfig(BaseModel):
+    document: dict[str, Any] | None = None
+    image: dict[str, Any] | None = None
+    audio: dict[str, Any] | None = None
+    video: dict[str, Any] | None = None
+    custom: dict[str, Any] | None = None
+
+    @staticmethod
+    def builder() -> FileUploadConfigBuilder:
+        return FileUploadConfigBuilder()
+
+
+class FileUploadConfigBuilder:
+    def __init__(self):
+        self._file_upload_config = FileUploadConfig()
+
+    def build(self) -> FileUploadConfig:
+        return self._file_upload_config
+
+    def document(self, document: dict[str, Any]) -> FileUploadConfigBuilder:
+        self._file_upload_config.document = document
+        return self
+
+    def image(self, image: dict[str, Any]) -> FileUploadConfigBuilder:
+        self._file_upload_config.image = image
+        return self
+
+    def audio(self, audio: dict[str, Any]) -> FileUploadConfigBuilder:
+        self._file_upload_config.audio = audio
+        return self
+
+    def video(self, video: dict[str, Any]) -> FileUploadConfigBuilder:
+        self._file_upload_config.video = video
+        return self
+
+    def custom(self, custom: dict[str, Any]) -> FileUploadConfigBuilder:
+        self._file_upload_config.custom = custom
+        return self

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

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class FileUploadInfo(BaseModel):
+    id: str | None = None
+    name: str | None = None
+    size: int | None = None
+    extension: str | None = None
+    mime_type: str | None = None
+    created_by: str | None = None
+    created_at: int | None = None
+
+    @staticmethod
+    def builder() -> FileUploadInfoBuilder:
+        return FileUploadInfoBuilder()
+
+
+class FileUploadInfoBuilder:
+    def __init__(self):
+        self._file_upload_info = FileUploadInfo()
+
+    def build(self) -> FileUploadInfo:
+        return self._file_upload_info
+
+    def id(self, id: str) -> FileUploadInfoBuilder:
+        self._file_upload_info.id = id
+        return self
+
+    def name(self, name: str) -> FileUploadInfoBuilder:
+        self._file_upload_info.name = name
+        return self
+
+    def size(self, size: int) -> FileUploadInfoBuilder:
+        self._file_upload_info.size = size
+        return self
+
+    def extension(self, extension: str) -> FileUploadInfoBuilder:
+        self._file_upload_info.extension = extension
+        return self
+
+    def mime_type(self, mime_type: str) -> FileUploadInfoBuilder:
+        self._file_upload_info.mime_type = mime_type
+        return self
+
+    def created_by(self, created_by: str) -> FileUploadInfoBuilder:
+        self._file_upload_info.created_by = created_by
+        return self
+
+    def created_at(self, created_at: int) -> FileUploadInfoBuilder:
+        self._file_upload_info.created_at = created_at
+        return self

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

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class GetInfoRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def builder() -> GetInfoRequestBuilder:
+        return GetInfoRequestBuilder()
+
+
+class GetInfoRequestBuilder:
+    def __init__(self):
+        get_info_request = GetInfoRequest()
+        get_info_request.http_method = HttpMethod.GET
+        get_info_request.uri = "/v1/info"
+        self._get_info_request = get_info_request
+
+    def build(self) -> GetInfoRequest:
+        return self._get_info_request

dify_oapi/api/{knowledge_base/v1/model/metadata/update_document_response.py → workflow/v1/model/get_info_response.py}

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from dify_oapi.core.model.base_response import BaseResponse
 
+from .app_info import AppInfo
 
-class UpdateDocumentResponse(BaseResponse):
-    result: str | None = None
+
+class GetInfoResponse(AppInfo, BaseResponse):
+    pass

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

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class GetParametersRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def builder() -> GetParametersRequestBuilder:
+        return GetParametersRequestBuilder()
+
+
+class GetParametersRequestBuilder:
+    def __init__(self):
+        get_parameters_request = GetParametersRequest()
+        get_parameters_request.http_method = HttpMethod.GET
+        get_parameters_request.uri = "/v1/parameters"
+        self._get_parameters_request = get_parameters_request
+
+    def build(self) -> GetParametersRequest:
+        return self._get_parameters_request

dify_oapi/api/{knowledge_base/v1/model/document/delete_response.py → workflow/v1/model/get_parameters_response.py}

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 from dify_oapi.core.model.base_response import BaseResponse
 
+from .parameters_info import ParametersInfo
 
-class DeleteResponse(BaseResponse):
-    """Response model for delete document API (204 No Content)"""
 
+class GetParametersResponse(ParametersInfo, BaseResponse):
     pass

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

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class GetSiteRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def builder() -> GetSiteRequestBuilder:
+        return GetSiteRequestBuilder()
+
+
+class GetSiteRequestBuilder:
+    def __init__(self):
+        get_site_request = GetSiteRequest()
+        get_site_request.http_method = HttpMethod.GET
+        get_site_request.uri = "/v1/site"
+        self._get_site_request = get_site_request
+
+    def build(self) -> GetSiteRequest:
+        return self._get_site_request

dify_oapi/api/{knowledge_base/v1/model/metadata/delete_response.py → workflow/v1/model/get_site_response.py}

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from dify_oapi.core.model.base_response import BaseResponse
 
+from .site_info import SiteInfo
 
-class DeleteResponse(BaseResponse):
-    """Empty response for 204 No Content"""
+
+class GetSiteResponse(SiteInfo, BaseResponse):
+    pass

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

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class GetWorkflowLogsRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def builder() -> GetWorkflowLogsRequestBuilder:
+        return GetWorkflowLogsRequestBuilder()
+
+
+class GetWorkflowLogsRequestBuilder:
+    def __init__(self):
+        get_workflow_logs_request = GetWorkflowLogsRequest()
+        get_workflow_logs_request.http_method = HttpMethod.GET
+        get_workflow_logs_request.uri = "/v1/workflows/logs"
+        self._get_workflow_logs_request = get_workflow_logs_request
+
+    def build(self) -> GetWorkflowLogsRequest:
+        return self._get_workflow_logs_request
+
+    def keyword(self, keyword: str) -> GetWorkflowLogsRequestBuilder:
+        self._get_workflow_logs_request.add_query("keyword", keyword)
+        return self
+
+    def status(self, status: str) -> GetWorkflowLogsRequestBuilder:
+        self._get_workflow_logs_request.add_query("status", status)
+        return self
+
+    def page(self, page: int) -> GetWorkflowLogsRequestBuilder:
+        self._get_workflow_logs_request.add_query("page", str(page))
+        return self
+
+    def limit(self, limit: int) -> GetWorkflowLogsRequestBuilder:
+        self._get_workflow_logs_request.add_query("limit", str(limit))
+        return self
+
+    def created_by_end_user_session_id(self, session_id: str) -> GetWorkflowLogsRequestBuilder:
+        self._get_workflow_logs_request.add_query("created_by_end_user_session_id", session_id)
+        return self
+
+    def created_by_account(self, account: str) -> GetWorkflowLogsRequestBuilder:
+        self._get_workflow_logs_request.add_query("created_by_account", account)
+        return self

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

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .workflow_log_info import WorkflowLogInfo
+
+
+class GetWorkflowLogsResponse(BaseResponse):
+    page: int | None = None
+    limit: int | None = None
+    total: int | None = None
+    has_more: bool | None = None
+    data: list[WorkflowLogInfo] | None = None

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

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class GetWorkflowRunDetailRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.workflow_run_id: str | None = None
+
+    @staticmethod
+    def builder() -> GetWorkflowRunDetailRequestBuilder:
+        return GetWorkflowRunDetailRequestBuilder()
+
+
+class GetWorkflowRunDetailRequestBuilder:
+    def __init__(self):
+        get_workflow_run_detail_request = GetWorkflowRunDetailRequest()
+        get_workflow_run_detail_request.http_method = HttpMethod.GET
+        get_workflow_run_detail_request.uri = "/v1/workflows/run/:workflow_run_id"
+        self._get_workflow_run_detail_request = get_workflow_run_detail_request
+
+    def build(self) -> GetWorkflowRunDetailRequest:
+        return self._get_workflow_run_detail_request
+
+    def workflow_run_id(self, workflow_run_id: str) -> GetWorkflowRunDetailRequestBuilder:
+        self._get_workflow_run_detail_request.workflow_run_id = workflow_run_id
+        self._get_workflow_run_detail_request.paths["workflow_run_id"] = workflow_run_id
+        return self

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

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from pydantic import field_validator
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .workflow_types import WorkflowStatus
+
+
+class GetWorkflowRunDetailResponse(BaseResponse):
+    id: str | None = None
+    workflow_id: str | None = None
+    status: WorkflowStatus | None = None
+    inputs: dict[str, Any] | None = None
+    outputs: dict[str, Any] | None = None
+    error: str | None = None
+    total_steps: int | None = None
+    total_tokens: int | None = None
+    created_at: int | None = None
+    finished_at: int | None = None
+    elapsed_time: float | None = None
+
+    @field_validator("inputs", "outputs", mode="before")
+    @classmethod
+    def parse_json_fields(cls, v: Any) -> dict[str, Any] | None:
+        if v is None:
+            return None
+        if isinstance(v, str):
+            try:
+                parsed = json.loads(v)
+                return parsed if isinstance(parsed, dict) else {}
+            except (json.JSONDecodeError, TypeError):
+                return {}
+        if isinstance(v, dict):
+            return v
+        return {}

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

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel
+
+from .execution_metadata import ExecutionMetadata
+from .workflow_types import NodeType, WorkflowStatus
+
+
+class NodeInfo(BaseModel):
+    id: str | None = None
+    node_id: str | None = None
+    node_type: NodeType | None = None
+    title: str | None = None
+    index: int | None = None
+    predecessor_node_id: str | None = None
+    inputs: dict[str, Any] | None = None
+    outputs: dict[str, Any] | None = None
+    status: WorkflowStatus | None = None
+    error: str | None = None
+    elapsed_time: float | None = None
+    execution_metadata: ExecutionMetadata | None = None
+    created_at: int | None = None
+
+    @staticmethod
+    def builder() -> NodeInfoBuilder:
+        return NodeInfoBuilder()
+
+
+class NodeInfoBuilder:
+    def __init__(self):
+        self._node_info = NodeInfo()
+
+    def build(self) -> NodeInfo:
+        return self._node_info
+
+    def id(self, id: str) -> NodeInfoBuilder:
+        self._node_info.id = id
+        return self
+
+    def node_id(self, node_id: str) -> NodeInfoBuilder:
+        self._node_info.node_id = node_id
+        return self
+
+    def node_type(self, node_type: NodeType) -> NodeInfoBuilder:
+        self._node_info.node_type = node_type
+        return self
+
+    def title(self, title: str) -> NodeInfoBuilder:
+        self._node_info.title = title
+        return self
+
+    def index(self, index: int) -> NodeInfoBuilder:
+        self._node_info.index = index
+        return self
+
+    def predecessor_node_id(self, predecessor_node_id: str) -> NodeInfoBuilder:
+        self._node_info.predecessor_node_id = predecessor_node_id
+        return self
+
+    def inputs(self, inputs: dict[str, Any]) -> NodeInfoBuilder:
+        self._node_info.inputs = inputs
+        return self
+
+    def outputs(self, outputs: dict[str, Any]) -> NodeInfoBuilder:
+        self._node_info.outputs = outputs
+        return self
+
+    def status(self, status: WorkflowStatus) -> NodeInfoBuilder:
+        self._node_info.status = status
+        return self
+
+    def error(self, error: str) -> NodeInfoBuilder:
+        self._node_info.error = error
+        return self
+
+    def elapsed_time(self, elapsed_time: float) -> NodeInfoBuilder:
+        self._node_info.elapsed_time = elapsed_time
+        return self
+
+    def execution_metadata(self, execution_metadata: ExecutionMetadata) -> NodeInfoBuilder:
+        self._node_info.execution_metadata = execution_metadata
+        return self
+
+    def created_at(self, created_at: int) -> NodeInfoBuilder:
+        self._node_info.created_at = created_at
+        return self

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

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .file_upload_config import FileUploadConfig
+from .system_parameters import SystemParameters
+from .user_input_form import UserInputForm
+
+
+class ParametersInfo(BaseModel):
+    user_input_form: list[UserInputForm] | None = None
+    file_upload: FileUploadConfig | None = None
+    system_parameters: SystemParameters | None = None
+
+    @staticmethod
+    def builder() -> ParametersInfoBuilder:
+        return ParametersInfoBuilder()
+
+
+class ParametersInfoBuilder:
+    def __init__(self):
+        self._parameters_info = ParametersInfo()
+
+    def build(self) -> ParametersInfo:
+        return self._parameters_info
+
+    def user_input_form(self, user_input_form: list[UserInputForm]) -> ParametersInfoBuilder:
+        self._parameters_info.user_input_form = user_input_form
+        return self
+
+    def file_upload(self, file_upload: FileUploadConfig) -> ParametersInfoBuilder:
+        self._parameters_info.file_upload = file_upload
+        return self
+
+    def system_parameters(self, system_parameters: SystemParameters) -> ParametersInfoBuilder:
+        self._parameters_info.system_parameters = system_parameters
+        return self

dify_oapi/api/workflow/v1/model/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/run_workflow_request_body.py

@@ -2,14 +2,17 @@ from __future__ import annotations
 
 from pydantic import BaseModel
 
-from .run_workflow_request_file import RunWorkflowRequestFile
+from .workflow_file_info import WorkflowFileInfo
+from .workflow_inputs import WorkflowInputs
+from .workflow_types import ResponseMode
 
 
 class RunWorkflowRequestBody(BaseModel):
-    inputs: dict | None = None
-    response_mode: str | None = None
+    inputs: WorkflowInputs | None = None
+    response_mode: ResponseMode | None = None
     user: str | None = None
-    files: list[RunWorkflowRequestFile] | None = None
+    files: list[WorkflowFileInfo] | None = None
+    trace_id: str | None = None
 
     @staticmethod
     def builder() -> RunWorkflowRequestBodyBuilder:
@@ -17,26 +20,28 @@ class RunWorkflowRequestBody(BaseModel):
 
 
 class RunWorkflowRequestBodyBuilder:
-    def __init__(self):
-        self._run_workflow_body = RunWorkflowRequestBody()
+    def __init__(self) -> None:
+        self._run_workflow_request_body = RunWorkflowRequestBody()
 
-    def build(self):
-        return self._run_workflow_body
+    def build(self) -> RunWorkflowRequestBody:
+        return self._run_workflow_request_body
 
-    def inputs(self, inputs: dict) -> RunWorkflowRequestBodyBuilder:
-        self._run_workflow_body.inputs = inputs
+    def inputs(self, inputs: WorkflowInputs) -> RunWorkflowRequestBodyBuilder:
+        self._run_workflow_request_body.inputs = inputs
         return self
 
-    def response_mode(self, response_mode: str) -> RunWorkflowRequestBodyBuilder:
-        if response_mode not in ["streaming", "blocking"]:
-            raise ValueError('response_mode must be either "streaming" or "blocking"')
-        self._run_workflow_body.response_mode = response_mode
+    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_body.user = user
+        self._run_workflow_request_body.user = user
         return self
 
-    def files(self, files: list[RunWorkflowRequestFile]) -> RunWorkflowRequestBodyBuilder:
-        self._run_workflow_body.files = files
+    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