dify-oapi2 0.1.0__py3-none-any.whl

dify_oapi/api/knowledge_base/v1/resource/metadata.py

@@ -0,0 +1,65 @@
+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.metadata.create_request import CreateRequest
+from ..model.metadata.create_response import CreateResponse
+from ..model.metadata.delete_request import DeleteRequest
+from ..model.metadata.delete_response import DeleteResponse
+from ..model.metadata.list_request import ListRequest
+from ..model.metadata.list_response import ListResponse
+from ..model.metadata.toggle_builtin_request import ToggleBuiltinRequest
+from ..model.metadata.toggle_builtin_response import ToggleBuiltinResponse
+from ..model.metadata.update_document_request import UpdateDocumentRequest
+from ..model.metadata.update_document_response import UpdateDocumentResponse
+from ..model.metadata.update_request import UpdateRequest
+from ..model.metadata.update_response import UpdateResponse
+
+
+class Metadata:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def create(self, request: CreateRequest, option: RequestOption | None = None) -> CreateResponse:
+        return Transport.execute(self.config, request, unmarshal_as=CreateResponse, option=option)
+
+    async def acreate(self, request: CreateRequest, option: RequestOption | None = None) -> CreateResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=CreateResponse, option=option)
+
+    def list(self, request: ListRequest, option: RequestOption | None = None) -> ListResponse:
+        return Transport.execute(self.config, request, unmarshal_as=ListResponse, option=option)
+
+    async def alist(self, request: ListRequest, option: RequestOption | None = None) -> ListResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=ListResponse, option=option)
+
+    def update(self, request: UpdateRequest, option: RequestOption | None = None) -> UpdateResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateResponse, option=option)
+
+    async def aupdate(self, request: UpdateRequest, option: RequestOption | None = None) -> UpdateResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=UpdateResponse, option=option)
+
+    def delete(self, request: DeleteRequest, option: RequestOption | None = None) -> DeleteResponse:
+        return Transport.execute(self.config, request, unmarshal_as=DeleteResponse, option=option)
+
+    async def adelete(self, request: DeleteRequest, option: RequestOption | None = None) -> DeleteResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=DeleteResponse, option=option)
+
+    def toggle_builtin(
+        self, request: ToggleBuiltinRequest, option: RequestOption | None = None
+    ) -> ToggleBuiltinResponse:
+        return Transport.execute(self.config, request, unmarshal_as=ToggleBuiltinResponse, option=option)
+
+    async def atoggle_builtin(
+        self, request: ToggleBuiltinRequest, option: RequestOption | None = None
+    ) -> ToggleBuiltinResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=ToggleBuiltinResponse, option=option)
+
+    def update_document(
+        self, request: UpdateDocumentRequest, option: RequestOption | None = None
+    ) -> UpdateDocumentResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateDocumentResponse, option=option)
+
+    async def aupdate_document(
+        self, request: UpdateDocumentRequest, option: RequestOption | None = None
+    ) -> UpdateDocumentResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=UpdateDocumentResponse, option=option)

dify_oapi/api/knowledge_base/v1/resource/segment.py

@@ -0,0 +1,110 @@
+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
+
+# Child chunk operations
+from ..model.segment.create_child_chunk_request import CreateChildChunkRequest
+from ..model.segment.create_child_chunk_response import CreateChildChunkResponse
+
+# Core segment operations
+from ..model.segment.create_request import CreateRequest
+from ..model.segment.create_response import CreateResponse
+from ..model.segment.delete_child_chunk_request import DeleteChildChunkRequest
+from ..model.segment.delete_child_chunk_response import DeleteChildChunkResponse
+from ..model.segment.delete_request import DeleteRequest
+from ..model.segment.delete_response import DeleteResponse
+from ..model.segment.get_request import GetRequest
+from ..model.segment.get_response import GetResponse
+from ..model.segment.list_child_chunks_request import ListChildChunksRequest
+from ..model.segment.list_child_chunks_response import ListChildChunksResponse
+from ..model.segment.list_request import ListRequest
+from ..model.segment.list_response import ListResponse
+from ..model.segment.update_child_chunk_request import UpdateChildChunkRequest
+from ..model.segment.update_child_chunk_response import UpdateChildChunkResponse
+from ..model.segment.update_request import UpdateRequest
+from ..model.segment.update_response import UpdateResponse
+
+
+class Segment:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    # Core segment operations
+    def create(self, request: CreateRequest, request_option: RequestOption) -> CreateResponse:
+        return Transport.execute(self.config, request, unmarshal_as=CreateResponse, option=request_option)
+
+    async def acreate(self, request: CreateRequest, request_option: RequestOption) -> CreateResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=CreateResponse, option=request_option)
+
+    def list(self, request: ListRequest, request_option: RequestOption) -> ListResponse:
+        return Transport.execute(self.config, request, unmarshal_as=ListResponse, option=request_option)
+
+    async def alist(self, request: ListRequest, request_option: RequestOption) -> ListResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=ListResponse, option=request_option)
+
+    def get(self, request: GetRequest, request_option: RequestOption) -> GetResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetResponse, option=request_option)
+
+    async def aget(self, request: GetRequest, request_option: RequestOption) -> GetResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=GetResponse, option=request_option)
+
+    def update(self, request: UpdateRequest, request_option: RequestOption) -> UpdateResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateResponse, option=request_option)
+
+    async def aupdate(self, request: UpdateRequest, request_option: RequestOption) -> UpdateResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=UpdateResponse, option=request_option)
+
+    def delete(self, request: DeleteRequest, request_option: RequestOption) -> DeleteResponse:
+        return Transport.execute(self.config, request, unmarshal_as=DeleteResponse, option=request_option)
+
+    async def adelete(self, request: DeleteRequest, request_option: RequestOption) -> DeleteResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=DeleteResponse, option=request_option)
+
+    # Child chunk operations
+    def create_child_chunk(
+        self, request: CreateChildChunkRequest, request_option: RequestOption
+    ) -> CreateChildChunkResponse:
+        return Transport.execute(self.config, request, unmarshal_as=CreateChildChunkResponse, option=request_option)
+
+    async def acreate_child_chunk(
+        self, request: CreateChildChunkRequest, request_option: RequestOption
+    ) -> CreateChildChunkResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=CreateChildChunkResponse, option=request_option
+        )
+
+    def list_child_chunks(
+        self, request: ListChildChunksRequest, request_option: RequestOption
+    ) -> ListChildChunksResponse:
+        return Transport.execute(self.config, request, unmarshal_as=ListChildChunksResponse, option=request_option)
+
+    async def alist_child_chunks(
+        self, request: ListChildChunksRequest, request_option: RequestOption
+    ) -> ListChildChunksResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=ListChildChunksResponse, option=request_option
+        )
+
+    def update_child_chunk(
+        self, request: UpdateChildChunkRequest, request_option: RequestOption
+    ) -> UpdateChildChunkResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateChildChunkResponse, option=request_option)
+
+    async def aupdate_child_chunk(
+        self, request: UpdateChildChunkRequest, request_option: RequestOption
+    ) -> UpdateChildChunkResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=UpdateChildChunkResponse, option=request_option
+        )
+
+    def delete_child_chunk(
+        self, request: DeleteChildChunkRequest, request_option: RequestOption
+    ) -> DeleteChildChunkResponse:
+        return Transport.execute(self.config, request, unmarshal_as=DeleteChildChunkResponse, option=request_option)
+
+    async def adelete_child_chunk(
+        self, request: DeleteChildChunkRequest, request_option: RequestOption
+    ) -> DeleteChildChunkResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=DeleteChildChunkResponse, option=request_option
+        )

dify_oapi/api/knowledge_base/v1/resource/tag.py

@@ -0,0 +1,65 @@
+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.tag.bind_request import BindRequest
+from ..model.tag.bind_response import BindResponse
+from ..model.tag.create_request import CreateRequest
+from ..model.tag.create_response import CreateResponse
+from ..model.tag.delete_request import DeleteRequest
+from ..model.tag.delete_response import DeleteResponse
+from ..model.tag.list_request import ListRequest
+from ..model.tag.list_response import ListResponse
+from ..model.tag.query_bound_request import QueryBoundRequest
+from ..model.tag.query_bound_response import QueryBoundResponse
+from ..model.tag.unbind_request import UnbindRequest
+from ..model.tag.unbind_response import UnbindResponse
+from ..model.tag.update_request import UpdateRequest
+from ..model.tag.update_response import UpdateResponse
+
+
+class Tag:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def create(self, request: CreateRequest, option: RequestOption | None = None) -> CreateResponse:
+        return Transport.execute(self.config, request, unmarshal_as=CreateResponse, option=option)
+
+    async def acreate(self, request: CreateRequest, option: RequestOption | None = None) -> CreateResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=CreateResponse, option=option)
+
+    def list(self, request: ListRequest, option: RequestOption | None = None) -> ListResponse:
+        return Transport.execute(self.config, request, unmarshal_as=ListResponse, option=option)
+
+    async def alist(self, request: ListRequest, option: RequestOption | None = None) -> ListResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=ListResponse, option=option)
+
+    def update(self, request: UpdateRequest, option: RequestOption | None = None) -> UpdateResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateResponse, option=option)
+
+    async def aupdate(self, request: UpdateRequest, option: RequestOption | None = None) -> UpdateResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=UpdateResponse, option=option)
+
+    def delete(self, request: DeleteRequest, option: RequestOption | None = None) -> DeleteResponse:
+        return Transport.execute(self.config, request, unmarshal_as=DeleteResponse, option=option)
+
+    async def adelete(self, request: DeleteRequest, option: RequestOption | None = None) -> DeleteResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=DeleteResponse, option=option)
+
+    def bind_tags(self, request: BindRequest, option: RequestOption | None = None) -> BindResponse:
+        return Transport.execute(self.config, request, unmarshal_as=BindResponse, option=option)
+
+    async def abind_tags(self, request: BindRequest, option: RequestOption | None = None) -> BindResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=BindResponse, option=option)
+
+    def unbind_tag(self, request: UnbindRequest, option: RequestOption | None = None) -> UnbindResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UnbindResponse, option=option)
+
+    async def aunbind_tag(self, request: UnbindRequest, option: RequestOption | None = None) -> UnbindResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=UnbindResponse, option=option)
+
+    def query_bound(self, request: QueryBoundRequest, option: RequestOption | None = None) -> QueryBoundResponse:
+        return Transport.execute(self.config, request, unmarshal_as=QueryBoundResponse, option=option)
+
+    async def aquery_bound(self, request: QueryBoundRequest, option: RequestOption | None = None) -> QueryBoundResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=QueryBoundResponse, option=option)

dify_oapi/api/knowledge_base/v1/version.py

@@ -0,0 +1,12 @@
+from dify_oapi.core.model.config import Config
+
+from .resource import Dataset, Document, Metadata, Segment, Tag
+
+
+class V1:
+    def __init__(self, config: Config):
+        self.dataset: Dataset = Dataset(config)
+        self.document: Document = Document(config)
+        self.metadata: Metadata = Metadata(config)
+        self.segment: Segment = Segment(config)
+        self.tag: Tag = Tag(config)

dify_oapi/api/workflow/service.py

@@ -0,0 +1,8 @@
+from dify_oapi.core.model.config import Config
+
+from .v1.version import V1
+
+
+class WorkflowService:
+    def __init__(self, config: Config) -> None:
+        self.v1: V1 = V1(config)

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

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from typing_extensions import Literal
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class GetWorkflowLogRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.keyword: str | None = None
+        self.status: str | None = None
+        self.page: int | None = None
+        self.limit: int | None = None
+
+    @staticmethod
+    def builder() -> GetWorkflowLogRequestBuilder:
+        return GetWorkflowLogRequestBuilder()
+
+
+class GetWorkflowLogRequestBuilder:
+    def __init__(self):
+        get_workflow_log_request = GetWorkflowLogRequest()
+        get_workflow_log_request.http_method = HttpMethod.GET
+        get_workflow_log_request.uri = "/v1/workflows/logs"
+        self._get_workflow_log_request = get_workflow_log_request
+
+    def build(self):
+        return self._get_workflow_log_request
+
+    def keyword(self, keyword: str) -> GetWorkflowLogRequestBuilder:
+        self._get_workflow_log_request.keyword = keyword
+        self._get_workflow_log_request.add_query("keyword", keyword)
+        return self
+
+    def status(self, status: Literal["succeeded", "failed", "stopped"]) -> GetWorkflowLogRequestBuilder:
+        self._get_workflow_log_request.status = status
+        self._get_workflow_log_request.add_query("status", status)
+        return self
+
+    def page(self, page: int) -> GetWorkflowLogRequestBuilder:
+        self._get_workflow_log_request.page = page
+        self._get_workflow_log_request.add_query("page", page)
+        return self
+
+    def limit(self, limit: int) -> GetWorkflowLogRequestBuilder:
+        self._get_workflow_log_request.limit = limit
+        self._get_workflow_log_request.add_query("limit", limit)
+        return self

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

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class GetWorkflowLogResponse(BaseResponse):
+    page: int | None = None
+    limit: int | None = None
+    total: int | None = None
+    has_more: bool | None = None
+    data: list[GetWorkflowLogResponseData] | None = None
+
+
+class GetWorkflowLogResponseData(BaseModel):
+    id: str | None = None
+    workflow_run: GetWorkflowLogResponseDataWorkflowRun | None = None
+    created_from: str | None = None
+    created_by_role: str | None = None
+    created_by_account: str | None = None
+    created_by_end_user: GetWorkflowLogResponseDataEndUser | None = None
+    created_at: int | None = None
+
+
+class GetWorkflowLogResponseDataWorkflowRun(BaseModel):
+    id: str | None = None
+    version: str | None = None
+    status: str | 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
+
+
+class GetWorkflowLogResponseDataEndUser(BaseModel):
+    id: str | None = None
+    type: str | None = None
+    is_anonymous: bool | None = None
+    session_id: str | None = None

dify_oapi/api/workflow/v1/model/get_workflow_result_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 GetWorkflowResultRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.workflow_id: str | None = None
+
+    @staticmethod
+    def builder() -> GetWorkflowResultRequestBuilder:
+        return GetWorkflowResultRequestBuilder()
+
+
+class GetWorkflowResultRequestBuilder:
+    def __init__(self):
+        get_workflow_request = GetWorkflowResultRequest()
+        get_workflow_request.http_method = HttpMethod.GET
+        get_workflow_request.uri = "/v1/workflows/run/:workflow_id"
+        self._get_workflow_request = get_workflow_request
+
+    def build(self):
+        return self._get_workflow_request
+
+    def workflow_id(self, workflow_id: str) -> GetWorkflowResultRequestBuilder:
+        self._get_workflow_request.workflow_id = workflow_id
+        self._get_workflow_request.paths["workflow_id"] = workflow_id
+        return self

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

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class GetWorkflowResultResponse(BaseResponse):
+    id: str | None = None
+    workflow_id: str | None = None
+    status: str | None = None
+    inputs: str | None = None
+    outputs: str | None = None
+    error: str | None = None
+    elapsed_time: float | None = None
+    total_tokens: int | None = None
+    total_steps: int | None = None
+    created_at: str | None = None
+    finished_at: str | None = None

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

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .run_workflow_request_body import RunWorkflowRequestBody
+
+
+class RunWorkflowRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.request_body: RunWorkflowRequestBody | None = None
+
+    @staticmethod
+    def builder() -> RunWorkflowRequestBuilder:
+        return RunWorkflowRequestBuilder()
+
+
+class RunWorkflowRequestBuilder:
+    def __init__(self) -> None:
+        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
+
+    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

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .run_workflow_request_file import RunWorkflowRequestFile
+
+
+class RunWorkflowRequestBody(BaseModel):
+    inputs: dict | None = None
+    response_mode: str | None = None
+    user: str | None = None
+    files: list[RunWorkflowRequestFile] | None = None
+
+    @staticmethod
+    def builder() -> RunWorkflowRequestBodyBuilder:
+        return RunWorkflowRequestBodyBuilder()
+
+
+class RunWorkflowRequestBodyBuilder:
+    def __init__(self):
+        self._run_workflow_body = RunWorkflowRequestBody()
+
+    def build(self):
+        return self._run_workflow_body
+
+    def inputs(self, inputs: dict) -> RunWorkflowRequestBodyBuilder:
+        self._run_workflow_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
+        return self
+
+    def user(self, user: str) -> RunWorkflowRequestBodyBuilder:
+        self._run_workflow_body.user = user
+        return self
+
+    def files(self, files: list[RunWorkflowRequestFile]) -> RunWorkflowRequestBodyBuilder:
+        self._run_workflow_body.files = files
+        return self

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

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, HttpUrl
+
+
+class RunWorkflowRequestFile(BaseModel):
+    type: str | None = None
+    transfer_method: str | None = None
+    url: HttpUrl | None = None
+    upload_file_id: str | None = None
+
+    @staticmethod
+    def builder() -> RunWorkflowRequestFileBuilder:
+        return RunWorkflowRequestFileBuilder()
+
+
+class RunWorkflowRequestFileBuilder:
+    def __init__(self):
+        self._run_workflow_request_file = RunWorkflowRequestFile()
+
+    def type(self, type_: str):
+        self._run_workflow_request_file.type = type_
+        return self
+
+    def transfer_method(self, transfer_method: str):
+        if transfer_method not in ("remote_url", "local_file"):
+            raise ValueError("Only 'remote_url' and 'local_file' are supported")
+        self._run_workflow_request_file.transfer_method = transfer_method
+        return self
+
+    def url(self, url: str):
+        self._run_workflow_request_file.url = HttpUrl(url=url)
+        return self
+
+    def upload_file_id(self, upload_file_id: str):
+        self._run_workflow_request_file.upload_file_id = upload_file_id
+        return self
+
+    def build(self) -> RunWorkflowRequestFile:
+        if (
+            self._run_workflow_request_file.transfer_method == "remote_url"
+            and self._run_workflow_request_file.url is None
+        ):
+            raise ValueError("Url needs to be set when transfer_method is set as remote_url")
+        if (
+            self._run_workflow_request_file.transfer_method == "local_file"
+            and self._run_workflow_request_file.upload_file_id is None
+        ):
+            raise ValueError("Upload file_id needs to be set when transfer_method is set as local_file")
+        return self._run_workflow_request_file

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

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class RunWorkflowResponse(BaseResponse):
+    workflow_run_id: str | None = None
+    task_id: str | None = None
+    data: RunWorkflowResponseData | None = None
+
+
+class RunWorkflowResponseData(BaseModel):
+    id: str | None = None
+    workflow_id: str | None = None
+    status: str | None = None
+    outputs: dict | 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

dify_oapi/api/workflow/v1/model/stop_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 .stop_workflow_request_body import StopWorkflowRequestBody
+
+
+class StopWorkflowRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.task_id: str | None = None
+        self.request_body: StopWorkflowRequestBody | None = None
+
+    @staticmethod
+    def builder() -> StopWorkflowRequestBuilder:
+        return StopWorkflowRequestBuilder()
+
+
+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 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)
+        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

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class StopWorkflowRequestBody(BaseModel):
+    user: str | None = None
+
+    @staticmethod
+    def builder() -> StopWorkflowRequestBodyBuilder:
+        return StopWorkflowRequestBodyBuilder()
+
+
+class StopWorkflowRequestBodyBuilder:
+    def __init__(self):
+        self._stop_workflow_request_body = StopWorkflowRequestBody()
+
+    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

@@ -0,0 +1,5 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class StopWorkflowResponse(BaseResponse):
+    result: str | None = None

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

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