dify-oapi2 0.1.0__py3-none-any.whl

dify_oapi/api/chat/service.py

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

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

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from io import BytesIO
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .audio_to_text_request_body import AudioToTextRequestBody
+
+
+class AudioToTextRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.file: BytesIO | None = None
+        self.request_body: AudioToTextRequestBody | None = None
+
+    @staticmethod
+    def builder() -> AudioToTextRequestBuilder:
+        return AudioToTextRequestBuilder()
+
+
+class AudioToTextRequestBuilder:
+    def __init__(self):
+        audio_to_text_request = AudioToTextRequest()
+        audio_to_text_request.http_method = HttpMethod.POST
+        audio_to_text_request.uri = "/v1/audio-to-text"
+        self._audio_to_text_request = audio_to_text_request
+
+    def build(self) -> AudioToTextRequest:
+        return self._audio_to_text_request
+
+    def request_body(self, request_body: AudioToTextRequestBody) -> AudioToTextRequestBuilder:
+        self._audio_to_text_request.request_body = request_body
+        self._audio_to_text_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self
+
+    def file(self, file: BytesIO, file_name: str) -> AudioToTextRequestBuilder:
+        self._audio_to_text_request.file = file
+        self._audio_to_text_request.files = {"file": (file_name, file)}
+        return self

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

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

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

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

dify_oapi/api/chat/v1/model/chat_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 .chat_request_body import ChatRequestBody
+
+
+class ChatRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.request_body: ChatRequestBody | None = None
+
+    @staticmethod
+    def builder() -> ChatRequestBuilder:
+        return ChatRequestBuilder()
+
+
+class ChatRequestBuilder:
+    def __init__(self) -> None:
+        chat_request = ChatRequest()
+        chat_request.http_method = HttpMethod.POST
+        chat_request.uri = "/v1/chat-messages"
+        self._chat_request: ChatRequest = chat_request
+
+    def request_body(self, request_body: ChatRequestBody) -> ChatRequestBuilder:
+        self._chat_request.request_body = request_body
+        self._chat_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self
+
+    def build(self) -> ChatRequest:
+        return self._chat_request

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

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .chat_request_file import ChatRequestFile
+
+
+class ChatRequestBody(BaseModel):
+    query: str | None = None
+    inputs: dict | None = None
+    response_mode: str | None = None
+    user: str | None = None
+    conversation_id: str | None = None
+    files: list[ChatRequestFile] | None = None
+    auto_generate_name: bool | None = None
+
+    @staticmethod
+    def builder() -> ChatRequestBodyBuilder:
+        return ChatRequestBodyBuilder()
+
+
+class ChatRequestBodyBuilder:
+    def __init__(self):
+        self._chat_request_body = ChatRequestBody()
+
+    def query(self, query: str) -> ChatRequestBodyBuilder:
+        self._chat_request_body.query = query
+        return self
+
+    def inputs(self, inputs: dict) -> ChatRequestBodyBuilder:
+        self._chat_request_body.inputs = inputs
+        return self
+
+    def response_mode(self, response_mode: str) -> ChatRequestBodyBuilder:
+        if response_mode not in ["streaming", "blocking"]:
+            raise ValueError('response_mode must be either "streaming" or "blocking"')
+        self._chat_request_body.response_mode = response_mode
+        return self
+
+    def user(self, user: str) -> ChatRequestBodyBuilder:
+        self._chat_request_body.user = user
+        return self
+
+    def conversation_id(self, conversation_id: str) -> ChatRequestBodyBuilder:
+        self._chat_request_body.conversation_id = conversation_id
+        return self
+
+    def files(self, files: list[ChatRequestFile]) -> ChatRequestBodyBuilder:
+        self._chat_request_body.files = files
+        return self
+
+    def auto_generate_name(self, auto_generate_name: bool) -> ChatRequestBodyBuilder:
+        self._chat_request_body.auto_generate_name = auto_generate_name
+        return self
+
+    def build(self):
+        return self._chat_request_body

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

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

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

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

dify_oapi/api/chat/v1/model/delete_conversation_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 .delete_conversation_request_body import DeleteConversationRequestBody
+
+
+class DeleteConversationRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.conversation_id: str | None = None
+        self.request_body: DeleteConversationRequestBody | None = None
+
+    @staticmethod
+    def builder() -> DeleteConversationRequestBuilder:
+        return DeleteConversationRequestBuilder()
+
+
+class DeleteConversationRequestBuilder:
+    def __init__(self):
+        delete_conversation_request = DeleteConversationRequest()
+        delete_conversation_request.http_method = HttpMethod.DELETE
+        delete_conversation_request.uri = "/v1/conversations/:conversation_id"
+        self._delete_conversation_request = delete_conversation_request
+
+    def request_body(self, request_body: DeleteConversationRequestBody) -> DeleteConversationRequestBuilder:
+        self._delete_conversation_request.request_body = request_body
+        self._delete_conversation_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self
+
+    def conversation_id(self, conversation_id: str) -> DeleteConversationRequestBuilder:
+        self._delete_conversation_request.conversation_id = conversation_id
+        self._delete_conversation_request.paths["conversation_id"] = conversation_id
+        return self
+
+    def build(self) -> DeleteConversationRequest:
+        return self._delete_conversation_request

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

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

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

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

dify_oapi/api/chat/v1/model/get_conversation_list_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 GetConversationListRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.user: str | None = None
+        self.last_id: str | None = None
+        self.limit: int | None = None
+        self.pinned: bool | None = None
+
+    @staticmethod
+    def builder() -> GetConversationListRequestBuilder:
+        return GetConversationListRequestBuilder()
+
+
+class GetConversationListRequestBuilder:
+    def __init__(self):
+        get_conversation_list_request = GetConversationListRequest()
+        get_conversation_list_request.http_method = HttpMethod.GET
+        get_conversation_list_request.uri = "/v1/conversations"
+        self._get_conversation_list_request = get_conversation_list_request
+
+    def user(self, user: str) -> GetConversationListRequestBuilder:
+        self._get_conversation_list_request.user = user
+        self._get_conversation_list_request.add_query("user", user)
+        return self
+
+    def last_id(self, last_id: str) -> GetConversationListRequestBuilder:
+        self._get_conversation_list_request.last_id = last_id
+        self._get_conversation_list_request.add_query("last_id", last_id)
+        return self
+
+    def limit(self, limit: int) -> GetConversationListRequestBuilder:
+        self._get_conversation_list_request.limit = limit
+        self._get_conversation_list_request.add_query("limit", limit)
+        return self
+
+    def pinned(self, pinned: bool) -> GetConversationListRequestBuilder:
+        self._get_conversation_list_request.pinned = pinned
+        self._get_conversation_list_request.add_query("pinned", str(pinned).lower())
+        return self
+
+    def build(self) -> GetConversationListRequest:
+        return self._get_conversation_list_request

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

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class GetConversationListResponse(BaseResponse):
+    data: list[GetConversationListData] | None = None
+    has_more: bool | None = None
+    limit: int | None = None
+
+
+class GetConversationListData(BaseModel):
+    id: str | None = None
+    name: str | None = None
+    inputs: dict | None = None
+    status: str | None = None
+    introduction: str | None = None
+    created_at: int | None = None
+    updated_at: int | None = None

dify_oapi/api/chat/v1/model/message_history_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 MessageHistoryRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.conversation_id: str | None = None
+        self.user: str | None = None
+        self.first_id: str | None = None
+        self.limit: int | None = None
+
+    @staticmethod
+    def builder() -> MessageHistoryRequestBuilder:
+        return MessageHistoryRequestBuilder()
+
+
+class MessageHistoryRequestBuilder:
+    def __init__(self):
+        message_history_request = MessageHistoryRequest()
+        message_history_request.http_method = HttpMethod.GET
+        message_history_request.uri = "/v1/messages"
+        self._message_history_request = message_history_request
+
+    def build(self) -> MessageHistoryRequest:
+        return self._message_history_request
+
+    def conversation_id(self, conversation_id: str):
+        self._message_history_request.conversation_id = conversation_id
+        self._message_history_request.add_query("conversation_id", conversation_id)
+        return self
+
+    def user(self, user: str):
+        self._message_history_request.user = user
+        self._message_history_request.add_query("user", user)
+        return self
+
+    def first_id(self, first_id: str):
+        self._message_history_request.first_id = first_id
+        self._message_history_request.add_query("first_id", first_id)
+        return self
+
+    def limit(self, limit: int):
+        self._message_history_request.limit = limit
+        self._message_history_request.add_query("limit", limit)
+        return self

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

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class MessageHistoryResponse(BaseResponse):
+    data: list[dict] | None = None
+    id: str | None = None
+    conversation_id: str | None = None
+    inputs: list[dict] | None = None
+    query: str | None = None
+    message_files: list[MessageHistoryResponseFile] | None = None
+    answer: str | None = None
+    created_at: int | None = None
+    feedback: MessageHistoryResponseFeedback | None = None
+    retriever_resources: list[dict] | None = None
+    has_more: bool | None = None
+    limit: int | None = None
+
+
+class MessageHistoryResponseFeedback(BaseModel):
+    rating: str | None = None
+
+
+class MessageHistoryResponseFile(BaseModel):
+    id: str | None = None
+    type: str | None = None
+    url: str | None = None
+    belongs_to: str | None = None
+    agent_thoughts: list[MessageHistoryResponseFileAgentThought] | None = None
+
+
+class MessageHistoryResponseFileAgentThought(BaseResponse):
+    id: str | None = None
+    message_id: str | None = None
+    position: int | None = None
+    thought: str | None = None
+    observation: str | None = None
+    tool: str | None = None
+    tool_input: str | None = None
+    created_at: int | None = None
+    message_files: list[MessageHistoryResponseFileAgentThoughtFile] | None = None
+    conversation_id: str | None = None
+
+
+class MessageHistoryResponseFileAgentThoughtFile(BaseModel):
+    file_id: str | None = None

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

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class MessageSuggestedRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.message_id: str | None = None
+        self.user: str | None = None
+
+    @staticmethod
+    def builder() -> MessageSuggestedRequestBuilder:
+        return MessageSuggestedRequestBuilder()
+
+
+class MessageSuggestedRequestBuilder:
+    def __init__(self):
+        message_suggested_request = MessageSuggestedRequest()
+        message_suggested_request.http_method = HttpMethod.GET
+        message_suggested_request.uri = "/v1/messages/:message_id/suggested"
+        self._message_suggested_request = message_suggested_request
+
+    def build(self) -> MessageSuggestedRequest:
+        return self._message_suggested_request
+
+    def message_id(self, message_id: str):
+        self._message_suggested_request.message_id = message_id
+        self._message_suggested_request.paths["message_id"] = message_id
+        return self
+
+    def user(self, user: str):
+        self._message_suggested_request.user = user
+        self._message_suggested_request.add_query("user", user)
+        return self

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

@@ -0,0 +1,6 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class MessageSuggestedResponse(BaseResponse):
+    result: str | None = None
+    data: list[str] | None = None

dify_oapi/api/chat/v1/model/rename_conversation_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 .rename_conversation_request_body import RenameConversationRequestBody
+
+
+class RenameConversationRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.conversation_id: str | None = None
+        self.request_body: RenameConversationRequestBody | None = None
+
+    @staticmethod
+    def builder() -> RenameConversationRequestBuilder:
+        return RenameConversationRequestBuilder()
+
+
+class RenameConversationRequestBuilder:
+    def __init__(self):
+        rename_conversation_request = RenameConversationRequest()
+        rename_conversation_request.http_method = HttpMethod.POST
+        rename_conversation_request.uri = "/v1/conversations/:conversation_id/name"
+        self._rename_conversation_request = rename_conversation_request
+
+    def build(self) -> RenameConversationRequest:
+        return self._rename_conversation_request
+
+    def request_body(self, request_body: RenameConversationRequestBody) -> RenameConversationRequestBuilder:
+        self._rename_conversation_request.request_body = request_body
+        self._rename_conversation_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self
+
+    def conversation_id(self, conversation_id: str) -> RenameConversationRequestBuilder:
+        self._rename_conversation_request.conversation_id = conversation_id
+        self._rename_conversation_request.paths["conversation_id"] = conversation_id
+        return self

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

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class RenameConversationRequestBody(BaseModel):
+    name: str | None = None
+    auto_generate: bool | None = None
+    user: str | None = None
+
+    @staticmethod
+    def builder() -> RenameConversationRequestBodyBuilder:
+        return RenameConversationRequestBodyBuilder()
+
+
+class RenameConversationRequestBodyBuilder:
+    def __init__(self):
+        self._rename_conversation_request_body = RenameConversationRequestBody()
+
+    def builder(self) -> RenameConversationRequestBody:
+        return self._rename_conversation_request_body
+
+    def name(self, name: str) -> RenameConversationRequestBodyBuilder:
+        self._rename_conversation_request_body.name = name
+        return self
+
+    def auto_generate(self, auto_generate: bool) -> RenameConversationRequestBodyBuilder:
+        self._rename_conversation_request_body.auto_generate = auto_generate
+        return self
+
+    def user(self, user: str) -> RenameConversationRequestBodyBuilder:
+        self._rename_conversation_request_body.user = user
+        return self

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

@@ -0,0 +1,11 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class RenameConversationResponse(BaseResponse):
+    id: str | None = None
+    result: str | None = None
+    inputs: dict | None = None
+    status: str | None = None
+    introduction: str | None = None
+    created_at: int | None = None
+    updated_at: int | None = None

dify_oapi/api/chat/v1/model/stop_chat_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_chat_request_body import StopChatRequestBody
+
+
+class StopChatRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.task_id: str | None = None
+        self.request_body: StopChatRequestBody | None = None
+
+    @staticmethod
+    def builder() -> StopChatRequestBuilder:
+        return StopChatRequestBuilder()
+
+
+class StopChatRequestBuilder:
+    def __init__(self) -> None:
+        stop_chat_request = StopChatRequest()
+        stop_chat_request.http_method = HttpMethod.POST
+        stop_chat_request.uri = "/v1/chat-messages/:task_id/stop"
+        self._stop_chat_request: StopChatRequest = stop_chat_request
+
+    def task_id(self, task_id: str) -> StopChatRequestBuilder:
+        self._stop_chat_request.task_id = task_id
+        self._stop_chat_request.paths["task_id"] = str(task_id)
+        return self
+
+    def request_body(self, request_body: StopChatRequestBody) -> StopChatRequestBuilder:
+        self._stop_chat_request.request_body = request_body
+        self._stop_chat_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self
+
+    def build(self) -> StopChatRequest:
+        return self._stop_chat_request