dify-oapi2 0.1.0__py3-none-any.whl

dify_oapi/api/chat/v1/model/stop_chat_request_body.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class StopChatRequestBody(BaseModel):
+    user: str | None = None
+
+    @staticmethod
+    def builder() -> StopChatRequestBodyBuilder:
+        return StopChatRequestBodyBuilder()
+
+
+class StopChatRequestBodyBuilder:
+    def __init__(self):
+        self._stop_chat_request_body = StopChatRequestBody()
+
+    def user(self, user: str) -> StopChatRequestBodyBuilder:
+        self._stop_chat_request_body.user = user
+        return self
+
+    def build(self) -> StopChatRequestBody:
+        return self._stop_chat_request_body

dify_oapi/api/chat/v1/model/stop_chat_response.py

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

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

@@ -0,0 +1,4 @@
+from .chat import *  # noqa F403
+from .conversation import *  # noqa 403
+from .message import *  # noqa 403
+from .audio import *  # noqa 403

dify_oapi/api/chat/v1/resource/audio.py

@@ -0,0 +1,17 @@
+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.audio_to_text_request import AudioToTextRequest
+from ..model.audio_to_text_response import AudioToTextResponse
+
+
+class Audio:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def to_text(self, request: AudioToTextRequest, option: RequestOption | None = None) -> AudioToTextResponse:
+        return Transport.execute(self.config, request, unmarshal_as=AudioToTextResponse, option=option)
+
+    async def ato_text(self, request: AudioToTextRequest, option: RequestOption | None = None) -> AudioToTextResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=AudioToTextResponse, option=option)

dify_oapi/api/chat/v1/resource/chat.py

@@ -0,0 +1,68 @@
+from collections.abc import AsyncGenerator, Generator
+from typing import Literal, overload
+
+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.chat_request import ChatRequest
+from ..model.chat_response import ChatResponse
+from ..model.stop_chat_request import StopChatRequest
+from ..model.stop_chat_response import StopChatResponse
+
+
+class Chat:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    @overload
+    def chat(
+        self, request: ChatRequest, option: RequestOption | None, stream: Literal[True]
+    ) -> Generator[bytes, None, None]: ...
+
+    @overload
+    def chat(self, request: ChatRequest, option: RequestOption | None, stream: Literal[False]) -> ChatResponse: ...
+
+    @overload
+    def chat(self, request: ChatRequest, option: RequestOption | None) -> ChatResponse: ...
+
+    def chat(
+        self,
+        request: ChatRequest,
+        option: RequestOption | None = None,
+        stream: bool = False,
+    ):
+        if stream:
+            return Transport.execute(self.config, request, option=option, stream=True)
+        else:
+            return Transport.execute(self.config, request, unmarshal_as=ChatResponse, option=option)
+
+    @overload
+    async def achat(
+        self, request: ChatRequest, option: RequestOption | None, stream: Literal[True]
+    ) -> AsyncGenerator[bytes, None]: ...
+
+    @overload
+    async def achat(
+        self, request: ChatRequest, option: RequestOption | None, stream: Literal[False]
+    ) -> ChatResponse: ...
+
+    @overload
+    async def achat(self, request: ChatRequest, option: RequestOption | None) -> ChatResponse: ...
+
+    async def achat(
+        self,
+        request: ChatRequest,
+        option: RequestOption | None = None,
+        stream: bool = False,
+    ):
+        if stream:
+            return await ATransport.aexecute(self.config, request, option=option, stream=True)
+        else:
+            return await ATransport.aexecute(self.config, request, unmarshal_as=ChatResponse, option=option)
+
+    def stop(self, request: StopChatRequest, option: RequestOption | None = None) -> StopChatResponse:
+        return Transport.execute(self.config, request, unmarshal_as=StopChatResponse, option=option)
+
+    async def astop(self, request: StopChatRequest, option: RequestOption | None = None) -> StopChatResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=StopChatResponse, option=option)

dify_oapi/api/chat/v1/resource/conversation.py

@@ -0,0 +1,59 @@
+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.delete_conversation_request import DeleteConversationRequest
+from ..model.delete_conversation_response import DeleteConversationResponse
+from ..model.get_conversation_list_request import GetConversationListRequest
+from ..model.get_conversation_list_response import GetConversationListResponse
+from ..model.rename_conversation_request import RenameConversationRequest
+from ..model.rename_conversation_response import RenameConversationResponse
+
+
+class Conversation:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def list(
+        self, request: GetConversationListRequest, option: RequestOption | None = None
+    ) -> GetConversationListResponse:
+        # Send request
+        return Transport.execute(
+            self.config,
+            request,
+            unmarshal_as=GetConversationListResponse,
+            option=option,
+        )
+
+    async def alist(
+        self, request: GetConversationListRequest, option: RequestOption | None = None
+    ) -> GetConversationListResponse:
+        # Send request
+        return await ATransport.aexecute(
+            self.config,
+            request,
+            unmarshal_as=GetConversationListResponse,
+            option=option,
+        )
+
+    def delete(
+        self, request: DeleteConversationRequest, option: RequestOption | None = None
+    ) -> DeleteConversationResponse:
+        return Transport.execute(self.config, request, unmarshal_as=DeleteConversationResponse, option=option)
+
+    async def adelete(
+        self, request: DeleteConversationRequest, option: RequestOption | None = None
+    ) -> DeleteConversationResponse:
+        # Send request
+        return await ATransport.aexecute(self.config, request, unmarshal_as=DeleteConversationResponse, option=option)
+
+    def rename(
+        self, request: RenameConversationRequest, option: RequestOption | None = None
+    ) -> RenameConversationResponse:
+        return Transport.execute(self.config, request, unmarshal_as=RenameConversationResponse, option=option)
+
+    async def arename(
+        self, request: RenameConversationRequest, option: RequestOption | None = None
+    ) -> RenameConversationResponse:
+        # Send request
+        return await ATransport.aexecute(self.config, request, unmarshal_as=RenameConversationResponse, option=option)

dify_oapi/api/chat/v1/resource/message.py

@@ -0,0 +1,35 @@
+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.message_history_request import MessageHistoryRequest
+from ..model.message_history_response import MessageHistoryResponse
+from ..model.message_suggested_request import MessageSuggestedRequest
+from ..model.message_suggested_response import MessageSuggestedResponse
+
+
+class Message:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def suggested(
+        self, request: MessageSuggestedRequest, option: RequestOption | None = None
+    ) -> MessageSuggestedResponse:
+        # Send request
+        return Transport.execute(self.config, request, unmarshal_as=MessageSuggestedResponse, option=option)
+
+    async def asuggested(
+        self, request: MessageSuggestedRequest, option: RequestOption | None = None
+    ) -> MessageSuggestedResponse:
+        # Send request
+        return await ATransport.aexecute(self.config, request, unmarshal_as=MessageSuggestedResponse, option=option)
+
+    def history(self, request: MessageHistoryRequest, option: RequestOption | None = None) -> MessageHistoryResponse:
+        # Send request
+        return Transport.execute(self.config, request, unmarshal_as=MessageHistoryResponse, option=option)
+
+    async def ahistory(
+        self, request: MessageHistoryRequest, option: RequestOption | None = None
+    ) -> MessageHistoryResponse:
+        # Send request
+        return await ATransport.aexecute(self.config, request, unmarshal_as=MessageHistoryResponse, option=option)

dify_oapi/api/chat/v1/version.py

@@ -0,0 +1,11 @@
+from dify_oapi.core.model.config import Config
+
+from .resource import Audio, Chat, Conversation, Message
+
+
+class V1:
+    def __init__(self, config: Config):
+        self.chat: Chat = Chat(config)
+        self.conversation: Conversation = Conversation(config)
+        self.message: Message = Message(config)
+        self.audio: Audio = Audio(config)

dify_oapi/api/completion/service.py

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

dify_oapi/api/completion/v1/model/completion_request.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .completion_request_body import CompletionRequestBody
+
+
+class CompletionRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.request_body: CompletionRequestBody | None = None
+
+    @staticmethod
+    def builder() -> CompletionRequestBuilder:
+        return CompletionRequestBuilder()
+
+
+class CompletionRequestBuilder:
+    def __init__(self) -> None:
+        completion_request = CompletionRequest()
+        completion_request.http_method = HttpMethod.POST
+        completion_request.uri = "/v1/completion-messages"
+        self._completion_request: CompletionRequest = completion_request
+
+    def request_body(self, request_body: CompletionRequestBody) -> CompletionRequestBuilder:
+        self._completion_request.request_body = request_body
+        self._completion_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        if request_body.inputs and (custom_inputs := request_body.inputs.custom_inputs):
+            self._completion_request.body["inputs"].update(custom_inputs)
+        return self
+
+    def build(self) -> CompletionRequest:
+        return self._completion_request

dify_oapi/api/completion/v1/model/completion_request_body.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .completion_request_body_input import CompletionRequestBodyInput
+from .completion_request_file import CompletionRequestFile
+
+
+class CompletionRequestBody(BaseModel):
+    inputs: CompletionRequestBodyInput | None = None
+    response_mode: str | None = None
+    user: str | None = None
+    files: list[CompletionRequestFile] | None = None
+
+    @staticmethod
+    def builder() -> CompletionRequestBodyBuilder:
+        return CompletionRequestBodyBuilder()
+
+
+class CompletionRequestBodyBuilder:
+    def __init__(self):
+        self._completion_request_body = CompletionRequestBody()
+
+    def inputs(self, inputs: CompletionRequestBodyInput) -> CompletionRequestBodyBuilder:
+        self._completion_request_body.inputs = inputs
+        return self
+
+    def response_mode(self, response_mode: str) -> CompletionRequestBodyBuilder:
+        if response_mode not in ["streaming", "blocking"]:
+            raise ValueError('response_mode must be either "streaming" or "blocking"')
+        self._completion_request_body.response_mode = response_mode
+        return self
+
+    def user(self, user: str) -> CompletionRequestBodyBuilder:
+        self._completion_request_body.user = user
+        return self
+
+    def files(self, files: list[CompletionRequestFile]) -> CompletionRequestBodyBuilder:
+        self._completion_request_body.files = files
+        return self
+
+    def build(self):
+        return self._completion_request_body

dify_oapi/api/completion/v1/model/completion_request_body_input.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class CompletionRequestBodyInput(BaseModel):
+    query: str | None = None
+    custom_inputs: dict[str, Any] | None = Field(None, exclude=True)
+
+    @staticmethod
+    def builder() -> CompletionRequestBodyInputBuilder:
+        return CompletionRequestBodyInputBuilder()
+
+
+class CompletionRequestBodyInputBuilder:
+    def __init__(self):
+        self._completion_request_body_input = CompletionRequestBodyInput()
+
+    def build(self) -> CompletionRequestBodyInput:
+        if self._completion_request_body_input.query is None:
+            raise ValueError("CompletionRequestBodyInput.query is None")
+        return self._completion_request_body_input
+
+    def query(self, query: str):
+        self._completion_request_body_input.query = query
+        return self
+
+    def custom_input(self, key: str, value: Any):
+        if self._completion_request_body_input.custom_inputs is None:
+            self._completion_request_body_input.custom_inputs = {}
+        self._completion_request_body_input.custom_inputs[key] = value
+        return self
+
+    def custom_inputs(self, custom_inputs: dict[str, Any]):
+        self._completion_request_body_input.custom_inputs = custom_inputs
+        return self

dify_oapi/api/completion/v1/model/completion_request_file.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, HttpUrl
+
+
+class CompletionRequestFile(BaseModel):
+    type: str | None = None
+    transfer_method: str | None = None
+    url: HttpUrl | None = None
+    upload_file_id: str | None = None
+
+    @staticmethod
+    def builder() -> CompletionRequestFileBuilder:
+        return CompletionRequestFileBuilder()
+
+
+class CompletionRequestFileBuilder:
+    def __init__(self):
+        self._completion_request_file = CompletionRequestFile()
+
+    def type(self, type_: str):
+        if type_ != "image":
+            raise ValueError("Only 'image' is supported")
+        self._completion_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._completion_request_file.transfer_method = transfer_method
+        return self
+
+    def url(self, url: str):
+        self._completion_request_file.url = HttpUrl(url=url)
+        return self
+
+    def upload_file_id(self, upload_file_id: str):
+        self._completion_request_file.upload_file_id = upload_file_id
+        return self
+
+    def build(self) -> CompletionRequestFile:
+        if self._completion_request_file.transfer_method == "remote_url" and self._completion_request_file.url is None:
+            raise ValueError("Url needs to be set when transfer_method is set as remote_url")
+        if (
+            self._completion_request_file.transfer_method == "local_file"
+            and self._completion_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._completion_request_file

dify_oapi/api/completion/v1/model/completion_response.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class CompletionResponse(BaseResponse):
+    message_id: str | None = None
+    mode: str | None = None
+    answer: str | None = None
+    metadata: CompletionResponseMetadata | None = None
+    created_at: int | None = None
+
+
+class CompletionResponseMetadata(BaseModel):
+    usage: dict | None = None
+    retriever_resources: list[dict] | None = None

dify_oapi/api/completion/v1/model/stop_completion_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_completion_request_body import StopCompletionRequestBody
+
+
+class StopCompletionRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.task_id: str | None = None
+        self.request_body: StopCompletionRequestBody | None = None
+
+    @staticmethod
+    def builder() -> StopCompletionRequestBuilder:
+        return StopCompletionRequestBuilder()
+
+
+class StopCompletionRequestBuilder:
+    def __init__(self) -> None:
+        stop_completion_request = StopCompletionRequest()
+        stop_completion_request.http_method = HttpMethod.POST
+        stop_completion_request.uri = "/v1/completion-messages/:task_id/stop"
+        self._stop_completion_request: StopCompletionRequest = stop_completion_request
+
+    def task_id(self, task_id: str) -> StopCompletionRequestBuilder:
+        self._stop_completion_request.task_id = task_id
+        self._stop_completion_request.paths["task_id"] = str(task_id)
+        return self
+
+    def request_body(self, request_body: StopCompletionRequestBody) -> StopCompletionRequestBuilder:
+        self._stop_completion_request.request_body = request_body
+        self._stop_completion_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self
+
+    def build(self) -> StopCompletionRequest:
+        return self._stop_completion_request

dify_oapi/api/completion/v1/model/stop_completion_request_body.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class StopCompletionRequestBody(BaseModel):
+    user: str | None = None
+
+    @staticmethod
+    def builder() -> StopCompletionRequestBodyBuilder:
+        return StopCompletionRequestBodyBuilder()
+
+
+class StopCompletionRequestBodyBuilder:
+    def __init__(self):
+        self._stop_completion_request_body = StopCompletionRequestBody()
+
+    def user(self, user: str) -> StopCompletionRequestBodyBuilder:
+        self._stop_completion_request_body.user = user
+        return self
+
+    def build(self) -> StopCompletionRequestBody:
+        return self._stop_completion_request_body

dify_oapi/api/completion/v1/model/stop_completion_response.py

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

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

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

dify_oapi/api/completion/v1/resource/completion.py

@@ -0,0 +1,84 @@
+from collections.abc import AsyncGenerator, Generator
+from typing import Literal, overload
+
+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.completion_request import CompletionRequest
+from ..model.completion_response import CompletionResponse
+from ..model.stop_completion_request import StopCompletionRequest
+from ..model.stop_completion_response import StopCompletionResponse
+
+
+class Completion:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    @overload
+    def completion(
+        self,
+        request: CompletionRequest,
+        option: RequestOption | None,
+        stream: Literal[True],
+    ) -> Generator[bytes, None, None]: ...
+
+    @overload
+    def completion(
+        self,
+        request: CompletionRequest,
+        option: RequestOption | None,
+        stream: Literal[False],
+    ) -> CompletionResponse: ...
+
+    @overload
+    def completion(self, request: CompletionRequest, option: RequestOption | None) -> CompletionResponse: ...
+
+    def completion(
+        self,
+        request: CompletionRequest,
+        option: RequestOption | None = None,
+        stream: bool = False,
+    ):
+        if stream:
+            return Transport.execute(self.config, request, option=option, stream=True)
+        else:
+            return Transport.execute(self.config, request, unmarshal_as=CompletionResponse, option=option)
+
+    @overload
+    async def acompletion(
+        self,
+        request: CompletionRequest,
+        option: RequestOption | None,
+        stream: Literal[True],
+    ) -> AsyncGenerator[bytes, None]: ...
+
+    @overload
+    async def acompletion(
+        self,
+        request: CompletionRequest,
+        option: RequestOption | None,
+        stream: Literal[False],
+    ) -> CompletionResponse: ...
+
+    @overload
+    async def acompletion(self, request: CompletionRequest, option: RequestOption | None) -> CompletionResponse: ...
+
+    async def acompletion(
+        self,
+        request: CompletionRequest,
+        option: RequestOption | None = None,
+        stream: bool = False,
+    ):
+        if stream:
+            return await ATransport.aexecute(self.config, request, option=option, stream=True)
+        else:
+            return await ATransport.aexecute(self.config, request, unmarshal_as=CompletionResponse, option=option)
+
+    def stop(self, request: StopCompletionRequest, option: RequestOption | None = None) -> StopCompletionResponse:
+        return Transport.execute(self.config, request, unmarshal_as=StopCompletionResponse, option=option)
+
+    async def astop(
+        self, request: StopCompletionRequest, option: RequestOption | None = None
+    ) -> StopCompletionResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=StopCompletionResponse, option=option)

dify_oapi/api/completion/v1/version.py

@@ -0,0 +1,8 @@
+from dify_oapi.core.model.config import Config
+
+from .resource import Completion
+
+
+class V1:
+    def __init__(self, config: Config):
+        self.completion: Completion = Completion(config)

dify_oapi/api/dify/service.py

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

dify_oapi/api/dify/v1/model/get_info_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 GetInfoRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.user: str | None = None
+
+    @staticmethod
+    def builder() -> GetInfoRequestBuilder:
+        return GetInfoRequestBuilder()
+
+
+class GetInfoRequestBuilder:
+    def __init__(self) -> None:
+        get_info_request = GetInfoRequest()
+        get_info_request.http_method = HttpMethod.GET
+        get_info_request.uri = "/v1/info"
+        self._get_info_request: GetInfoRequest = get_info_request
+
+    def build(self) -> GetInfoRequest:
+        return self._get_info_request
+
+    def user(self, user: str) -> GetInfoRequestBuilder:
+        self._get_info_request.user = user
+        self._get_info_request.add_query("user", user)
+        return self

dify_oapi/api/dify/v1/model/get_info_response.py

@@ -0,0 +1,7 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class GetInfoResponse(BaseResponse):
+    name: str | None = None
+    description: str | None = None
+    tags: list[str] | None = None