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

dify_oapi/api/chatflow/v1/model/retriever_resource.py

@@ -0,0 +1,58 @@
+from pydantic import BaseModel
+
+
+class RetrieverResource(BaseModel):
+    """Knowledge retrieval resource model."""
+
+    position: int | None = None
+    dataset_id: str | None = None
+    dataset_name: str | None = None
+    document_id: str | None = None
+    document_name: str | None = None
+    segment_id: str | None = None
+    score: float | None = None
+    content: str | None = None
+
+    @staticmethod
+    def builder() -> "RetrieverResourceBuilder":
+        return RetrieverResourceBuilder()
+
+
+class RetrieverResourceBuilder:
+    def __init__(self):
+        self._retriever_resource = RetrieverResource()
+
+    def build(self) -> RetrieverResource:
+        return self._retriever_resource
+
+    def position(self, position: int) -> "RetrieverResourceBuilder":
+        self._retriever_resource.position = position
+        return self
+
+    def dataset_id(self, dataset_id: str) -> "RetrieverResourceBuilder":
+        self._retriever_resource.dataset_id = dataset_id
+        return self
+
+    def dataset_name(self, dataset_name: str) -> "RetrieverResourceBuilder":
+        self._retriever_resource.dataset_name = dataset_name
+        return self
+
+    def document_id(self, document_id: str) -> "RetrieverResourceBuilder":
+        self._retriever_resource.document_id = document_id
+        return self
+
+    def document_name(self, document_name: str) -> "RetrieverResourceBuilder":
+        self._retriever_resource.document_name = document_name
+        return self
+
+    def segment_id(self, segment_id: str) -> "RetrieverResourceBuilder":
+        self._retriever_resource.segment_id = segment_id
+        return self
+
+    def score(self, score: float) -> "RetrieverResourceBuilder":
+        self._retriever_resource.score = score
+        return self
+
+    def content(self, content: str) -> "RetrieverResourceBuilder":
+        self._retriever_resource.content = content
+        return self

dify_oapi/api/chatflow/v1/model/send_chat_message_request.py

@@ -0,0 +1,30 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .send_chat_message_request_body import SendChatMessageRequestBody
+
+
+class SendChatMessageRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.request_body: SendChatMessageRequestBody | None = None
+
+    @staticmethod
+    def builder() -> "SendChatMessageRequestBuilder":
+        return SendChatMessageRequestBuilder()
+
+
+class SendChatMessageRequestBuilder:
+    def __init__(self):
+        send_chat_message_request = SendChatMessageRequest()
+        send_chat_message_request.http_method = HttpMethod.POST
+        send_chat_message_request.uri = "/v1/chat-messages"
+        self._send_chat_message_request = send_chat_message_request
+
+    def build(self) -> SendChatMessageRequest:
+        return self._send_chat_message_request
+
+    def request_body(self, request_body: SendChatMessageRequestBody) -> "SendChatMessageRequestBuilder":
+        self._send_chat_message_request.request_body = request_body
+        self._send_chat_message_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

dify_oapi/api/chatflow/v1/model/send_chat_message_request_body.py

@@ -0,0 +1,54 @@
+from pydantic import BaseModel
+
+from .chat_file import ChatFile
+from .chatflow_types import ResponseMode
+
+
+class SendChatMessageRequestBody(BaseModel):
+    query: str | None = None
+    inputs: dict[str, str] | None = None
+    response_mode: ResponseMode | None = None
+    user: str | None = None
+    conversation_id: str | None = None
+    files: list[ChatFile] | None = None
+    auto_generate_name: bool | None = None
+
+    @staticmethod
+    def builder() -> "SendChatMessageRequestBodyBuilder":
+        return SendChatMessageRequestBodyBuilder()
+
+
+class SendChatMessageRequestBodyBuilder:
+    def __init__(self):
+        self._send_chat_message_request_body = SendChatMessageRequestBody()
+
+    def build(self) -> SendChatMessageRequestBody:
+        return self._send_chat_message_request_body
+
+    def query(self, query: str) -> "SendChatMessageRequestBodyBuilder":
+        self._send_chat_message_request_body.query = query
+        return self
+
+    def inputs(self, inputs: dict[str, str]) -> "SendChatMessageRequestBodyBuilder":
+        self._send_chat_message_request_body.inputs = inputs
+        return self
+
+    def response_mode(self, response_mode: ResponseMode) -> "SendChatMessageRequestBodyBuilder":
+        self._send_chat_message_request_body.response_mode = response_mode
+        return self
+
+    def user(self, user: str) -> "SendChatMessageRequestBodyBuilder":
+        self._send_chat_message_request_body.user = user
+        return self
+
+    def conversation_id(self, conversation_id: str) -> "SendChatMessageRequestBodyBuilder":
+        self._send_chat_message_request_body.conversation_id = conversation_id
+        return self
+
+    def files(self, files: list[ChatFile]) -> "SendChatMessageRequestBodyBuilder":
+        self._send_chat_message_request_body.files = files
+        return self
+
+    def auto_generate_name(self, auto_generate_name: bool) -> "SendChatMessageRequestBodyBuilder":
+        self._send_chat_message_request_body.auto_generate_name = auto_generate_name
+        return self

dify_oapi/api/chatflow/v1/model/send_chat_message_response.py

@@ -0,0 +1,7 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .chat_message import ChatMessage
+
+
+class SendChatMessageResponse(ChatMessage, BaseResponse):
+    pass

dify_oapi/api/chatflow/v1/model/stop_chat_message_request.py

@@ -0,0 +1,36 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .stop_chat_message_request_body import StopChatMessageRequestBody
+
+
+class StopChatMessageRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.request_body: StopChatMessageRequestBody | None = None
+        self.task_id: str | None = None
+
+    @staticmethod
+    def builder() -> "StopChatMessageRequestBuilder":
+        return StopChatMessageRequestBuilder()
+
+
+class StopChatMessageRequestBuilder:
+    def __init__(self):
+        stop_chat_message_request = StopChatMessageRequest()
+        stop_chat_message_request.http_method = HttpMethod.POST
+        stop_chat_message_request.uri = "/v1/chat-messages/:task_id/stop"
+        self._stop_chat_message_request = stop_chat_message_request
+
+    def build(self) -> StopChatMessageRequest:
+        return self._stop_chat_message_request
+
+    def task_id(self, task_id: str) -> "StopChatMessageRequestBuilder":
+        self._stop_chat_message_request.task_id = task_id
+        self._stop_chat_message_request.paths["task_id"] = task_id
+        return self
+
+    def request_body(self, request_body: StopChatMessageRequestBody) -> "StopChatMessageRequestBuilder":
+        self._stop_chat_message_request.request_body = request_body
+        self._stop_chat_message_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

dify_oapi/api/chatflow/v1/model/stop_chat_message_request_body.py

@@ -0,0 +1,21 @@
+from pydantic import BaseModel
+
+
+class StopChatMessageRequestBody(BaseModel):
+    user: str | None = None
+
+    @staticmethod
+    def builder() -> "StopChatMessageRequestBodyBuilder":
+        return StopChatMessageRequestBodyBuilder()
+
+
+class StopChatMessageRequestBodyBuilder:
+    def __init__(self):
+        self._stop_chat_message_request_body = StopChatMessageRequestBody()
+
+    def build(self) -> StopChatMessageRequestBody:
+        return self._stop_chat_message_request_body
+
+    def user(self, user: str) -> "StopChatMessageRequestBodyBuilder":
+        self._stop_chat_message_request_body.user = user
+        return self

dify_oapi/api/chatflow/v1/model/stop_chat_message_response.py

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

dify_oapi/api/chatflow/v1/model/text_to_audio_request.py

@@ -0,0 +1,30 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .text_to_audio_request_body import TextToAudioRequestBody
+
+
+class TextToAudioRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.request_body: TextToAudioRequestBody | None = None
+
+    @staticmethod
+    def builder() -> "TextToAudioRequestBuilder":
+        return TextToAudioRequestBuilder()
+
+
+class TextToAudioRequestBuilder:
+    def __init__(self):
+        text_to_audio_request = TextToAudioRequest()
+        text_to_audio_request.http_method = HttpMethod.POST
+        text_to_audio_request.uri = "/v1/text-to-audio"
+        self._text_to_audio_request = text_to_audio_request
+
+    def build(self) -> TextToAudioRequest:
+        return self._text_to_audio_request
+
+    def request_body(self, request_body: TextToAudioRequestBody) -> "TextToAudioRequestBuilder":
+        self._text_to_audio_request.request_body = request_body
+        self._text_to_audio_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

dify_oapi/api/chatflow/v1/model/text_to_audio_request_body.py

@@ -0,0 +1,36 @@
+from pydantic import BaseModel
+
+
+class TextToAudioRequestBody(BaseModel):
+    message_id: str | None = None
+    text: str | None = None
+    user: str | None = None
+    streaming: bool | None = None
+
+    @staticmethod
+    def builder() -> "TextToAudioRequestBodyBuilder":
+        return TextToAudioRequestBodyBuilder()
+
+
+class TextToAudioRequestBodyBuilder:
+    def __init__(self):
+        self._text_to_audio_request_body = TextToAudioRequestBody()
+
+    def build(self) -> TextToAudioRequestBody:
+        return self._text_to_audio_request_body
+
+    def message_id(self, message_id: str) -> "TextToAudioRequestBodyBuilder":
+        self._text_to_audio_request_body.message_id = message_id
+        return self
+
+    def text(self, text: str) -> "TextToAudioRequestBodyBuilder":
+        self._text_to_audio_request_body.text = text
+        return self
+
+    def user(self, user: str) -> "TextToAudioRequestBodyBuilder":
+        self._text_to_audio_request_body.user = user
+        return self
+
+    def streaming(self, streaming: bool) -> "TextToAudioRequestBodyBuilder":
+        self._text_to_audio_request_body.streaming = streaming
+        return self

dify_oapi/api/chatflow/v1/model/text_to_audio_response.py

@@ -0,0 +1,19 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class TextToAudioResponse(BaseResponse):
+    # Binary audio data response - handled by Transport layer
+    # Response content type: audio/wav or audio/mp3
+    pass
+
+    @staticmethod
+    def builder() -> "TextToAudioResponseBuilder":
+        return TextToAudioResponseBuilder()
+
+
+class TextToAudioResponseBuilder:
+    def __init__(self):
+        self._text_to_audio_response = TextToAudioResponse()
+
+    def build(self) -> TextToAudioResponse:
+        return self._text_to_audio_response

dify_oapi/api/chatflow/v1/model/tool_icon.py

@@ -0,0 +1,48 @@
+from typing import Union
+
+from pydantic import BaseModel
+
+
+class ToolIconDetail(BaseModel):
+    background: str | None = None
+    content: str | None = None
+
+    @staticmethod
+    def builder() -> "ToolIconDetailBuilder":
+        return ToolIconDetailBuilder()
+
+
+class ToolIconDetailBuilder:
+    def __init__(self):
+        self._tool_icon_detail = ToolIconDetail()
+
+    def build(self) -> ToolIconDetail:
+        return self._tool_icon_detail
+
+    def background(self, background: str) -> "ToolIconDetailBuilder":
+        self._tool_icon_detail.background = background
+        return self
+
+    def content(self, content: str) -> "ToolIconDetailBuilder":
+        self._tool_icon_detail.content = content
+        return self
+
+
+class AppMeta(BaseModel):
+    tool_icons: dict[str, Union[str, ToolIconDetail]] | None = None
+
+    @staticmethod
+    def builder() -> "AppMetaBuilder":
+        return AppMetaBuilder()
+
+
+class AppMetaBuilder:
+    def __init__(self):
+        self._app_meta = AppMeta()
+
+    def build(self) -> AppMeta:
+        return self._app_meta
+
+    def tool_icons(self, tool_icons: dict[str, Union[str, ToolIconDetail]]) -> "AppMetaBuilder":
+        self._app_meta.tool_icons = tool_icons
+        return self

dify_oapi/api/chatflow/v1/model/update_annotation_request.py

@@ -0,0 +1,36 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .update_annotation_request_body import UpdateAnnotationRequestBody
+
+
+class UpdateAnnotationRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.request_body: UpdateAnnotationRequestBody | None = None
+        self.annotation_id: str | None = None
+
+    @staticmethod
+    def builder() -> "UpdateAnnotationRequestBuilder":
+        return UpdateAnnotationRequestBuilder()
+
+
+class UpdateAnnotationRequestBuilder:
+    def __init__(self):
+        update_annotation_request = UpdateAnnotationRequest()
+        update_annotation_request.http_method = HttpMethod.PUT
+        update_annotation_request.uri = "/v1/apps/annotations/:annotation_id"
+        self._update_annotation_request = update_annotation_request
+
+    def build(self) -> UpdateAnnotationRequest:
+        return self._update_annotation_request
+
+    def annotation_id(self, annotation_id: str) -> "UpdateAnnotationRequestBuilder":
+        self._update_annotation_request.annotation_id = annotation_id
+        self._update_annotation_request.paths["annotation_id"] = annotation_id
+        return self
+
+    def request_body(self, request_body: UpdateAnnotationRequestBody) -> "UpdateAnnotationRequestBuilder":
+        self._update_annotation_request.request_body = request_body
+        self._update_annotation_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

dify_oapi/api/chatflow/v1/model/update_annotation_request_body.py

@@ -0,0 +1,28 @@
+from pydantic import BaseModel
+
+
+class UpdateAnnotationRequestBody(BaseModel):
+    """Request body for updating annotation."""
+
+    question: str | None = None
+    answer: str | None = None
+
+    @staticmethod
+    def builder() -> "UpdateAnnotationRequestBodyBuilder":
+        return UpdateAnnotationRequestBodyBuilder()
+
+
+class UpdateAnnotationRequestBodyBuilder:
+    def __init__(self):
+        self._update_annotation_request_body = UpdateAnnotationRequestBody()
+
+    def build(self) -> UpdateAnnotationRequestBody:
+        return self._update_annotation_request_body
+
+    def question(self, question: str) -> "UpdateAnnotationRequestBodyBuilder":
+        self._update_annotation_request_body.question = question
+        return self
+
+    def answer(self, answer: str) -> "UpdateAnnotationRequestBodyBuilder":
+        self._update_annotation_request_body.answer = answer
+        return self

dify_oapi/api/chatflow/v1/model/update_annotation_response.py

@@ -0,0 +1,9 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .annotation_info import AnnotationInfo
+
+
+class UpdateAnnotationResponse(AnnotationInfo, BaseResponse):
+    """Response for updating annotation."""
+
+    pass

dify_oapi/api/chatflow/v1/model/upload_file_request.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from io import BytesIO
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class UploadFileRequest(BaseRequest):
+    """Upload file request model."""
+
+    def __init__(self):
+        super().__init__()
+        self.file: BytesIO | None = None
+        self.user: str | None = None
+
+    @staticmethod
+    def builder() -> UploadFileRequestBuilder:
+        return UploadFileRequestBuilder()
+
+
+class UploadFileRequestBuilder:
+    def __init__(self):
+        upload_file_request = UploadFileRequest()
+        upload_file_request.http_method = HttpMethod.POST
+        upload_file_request.uri = "/v1/files/upload"
+        self._upload_file_request = upload_file_request
+
+    def build(self) -> UploadFileRequest:
+        return self._upload_file_request
+
+    def file(self, file: BytesIO, file_name: str | None = None) -> UploadFileRequestBuilder:
+        self._upload_file_request.file = file
+        file_name = file_name or "upload"
+        self._upload_file_request.files = {"file": (file_name, file)}
+        return self
+
+    def user(self, user: str) -> UploadFileRequestBuilder:
+        self._upload_file_request.user = user
+        self._upload_file_request.body = {"user": user}
+        return self

dify_oapi/api/chatflow/v1/model/upload_file_response.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .file_info import FileInfo
+
+
+class UploadFileResponse(FileInfo, BaseResponse):
+    """Upload file response model."""
+
+    pass

dify_oapi/api/chatflow/v1/model/usage_info.py

@@ -0,0 +1,78 @@
+from pydantic import BaseModel
+
+
+class UsageInfo(BaseModel):
+    """Token usage information model."""
+
+    prompt_tokens: int | None = None
+    prompt_unit_price: str | None = None
+    prompt_price_unit: str | None = None
+    prompt_price: str | None = None
+    completion_tokens: int | None = None
+    completion_unit_price: str | None = None
+    completion_price_unit: str | None = None
+    completion_price: str | None = None
+    total_tokens: int | None = None
+    total_price: str | None = None
+    currency: str | None = None
+    latency: float | None = None
+
+    @staticmethod
+    def builder() -> "UsageInfoBuilder":
+        return UsageInfoBuilder()
+
+
+class UsageInfoBuilder:
+    def __init__(self):
+        self._usage_info = UsageInfo()
+
+    def build(self) -> UsageInfo:
+        return self._usage_info
+
+    def prompt_tokens(self, prompt_tokens: int) -> "UsageInfoBuilder":
+        self._usage_info.prompt_tokens = prompt_tokens
+        return self
+
+    def prompt_unit_price(self, prompt_unit_price: str) -> "UsageInfoBuilder":
+        self._usage_info.prompt_unit_price = prompt_unit_price
+        return self
+
+    def prompt_price_unit(self, prompt_price_unit: str) -> "UsageInfoBuilder":
+        self._usage_info.prompt_price_unit = prompt_price_unit
+        return self
+
+    def prompt_price(self, prompt_price: str) -> "UsageInfoBuilder":
+        self._usage_info.prompt_price = prompt_price
+        return self
+
+    def completion_tokens(self, completion_tokens: int) -> "UsageInfoBuilder":
+        self._usage_info.completion_tokens = completion_tokens
+        return self
+
+    def completion_unit_price(self, completion_unit_price: str) -> "UsageInfoBuilder":
+        self._usage_info.completion_unit_price = completion_unit_price
+        return self
+
+    def completion_price_unit(self, completion_price_unit: str) -> "UsageInfoBuilder":
+        self._usage_info.completion_price_unit = completion_price_unit
+        return self
+
+    def completion_price(self, completion_price: str) -> "UsageInfoBuilder":
+        self._usage_info.completion_price = completion_price
+        return self
+
+    def total_tokens(self, total_tokens: int) -> "UsageInfoBuilder":
+        self._usage_info.total_tokens = total_tokens
+        return self
+
+    def total_price(self, total_price: str) -> "UsageInfoBuilder":
+        self._usage_info.total_price = total_price
+        return self
+
+    def currency(self, currency: str) -> "UsageInfoBuilder":
+        self._usage_info.currency = currency
+        return self
+
+    def latency(self, latency: float) -> "UsageInfoBuilder":
+        self._usage_info.latency = latency
+        return self