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

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

@@ -0,0 +1,36 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .chatflow_types import AnnotationAction
+
+
+class AnnotationReplyStatusRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.action: AnnotationAction | None = None
+        self.job_id: str | None = None
+
+    @staticmethod
+    def builder() -> "AnnotationReplyStatusRequestBuilder":
+        return AnnotationReplyStatusRequestBuilder()
+
+
+class AnnotationReplyStatusRequestBuilder:
+    def __init__(self):
+        annotation_reply_status_request = AnnotationReplyStatusRequest()
+        annotation_reply_status_request.http_method = HttpMethod.GET
+        annotation_reply_status_request.uri = "/v1/apps/annotation-reply/:action/status/:job_id"
+        self._annotation_reply_status_request = annotation_reply_status_request
+
+    def build(self) -> AnnotationReplyStatusRequest:
+        return self._annotation_reply_status_request
+
+    def action(self, action: AnnotationAction) -> "AnnotationReplyStatusRequestBuilder":
+        self._annotation_reply_status_request.action = action
+        self._annotation_reply_status_request.paths["action"] = action
+        return self
+
+    def job_id(self, job_id: str) -> "AnnotationReplyStatusRequestBuilder":
+        self._annotation_reply_status_request.job_id = job_id
+        self._annotation_reply_status_request.paths["job_id"] = job_id
+        return self

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

@@ -0,0 +1,11 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .chatflow_types import JobStatus
+
+
+class AnnotationReplyStatusResponse(BaseResponse):
+    """Response for annotation reply status."""
+
+    job_id: str | None = None
+    job_status: JobStatus | None = None
+    error_msg: str | None = None

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

@@ -0,0 +1,33 @@
+from pydantic import BaseModel
+
+
+class AppInfo(BaseModel):
+    """Application information model."""
+
+    name: str | None = None
+    description: str | None = None
+    tags: list[str] | None = None
+
+    @staticmethod
+    def builder() -> "AppInfoBuilder":
+        return AppInfoBuilder()
+
+
+class AppInfoBuilder:
+    def __init__(self):
+        self._app_info = AppInfo()
+
+    def build(self) -> AppInfo:
+        return self._app_info
+
+    def name(self, name: str) -> "AppInfoBuilder":
+        self._app_info.name = name
+        return self
+
+    def description(self, description: str) -> "AppInfoBuilder":
+        self._app_info.description = description
+        return self
+
+    def tags(self, tags: list[str]) -> "AppInfoBuilder":
+        self._app_info.tags = tags
+        return self

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

@@ -0,0 +1,276 @@
+from pydantic import BaseModel
+
+from .chatflow_types import AutoPlay, TransferMethod
+from .user_input_form import UserInputFormItem
+
+
+class SuggestedQuestionsAfterAnswer(BaseModel):
+    enabled: bool
+
+    @staticmethod
+    def builder() -> "SuggestedQuestionsAfterAnswerBuilder":
+        return SuggestedQuestionsAfterAnswerBuilder()
+
+
+class SuggestedQuestionsAfterAnswerBuilder:
+    def __init__(self):
+        self._suggested_questions_after_answer = SuggestedQuestionsAfterAnswer(enabled=False)
+
+    def build(self) -> SuggestedQuestionsAfterAnswer:
+        return self._suggested_questions_after_answer
+
+    def enabled(self, enabled: bool) -> "SuggestedQuestionsAfterAnswerBuilder":
+        self._suggested_questions_after_answer.enabled = enabled
+        return self
+
+
+class SpeechToText(BaseModel):
+    enabled: bool
+
+    @staticmethod
+    def builder() -> "SpeechToTextBuilder":
+        return SpeechToTextBuilder()
+
+
+class SpeechToTextBuilder:
+    def __init__(self):
+        self._speech_to_text = SpeechToText(enabled=False)
+
+    def build(self) -> SpeechToText:
+        return self._speech_to_text
+
+    def enabled(self, enabled: bool) -> "SpeechToTextBuilder":
+        self._speech_to_text.enabled = enabled
+        return self
+
+
+class TextToSpeech(BaseModel):
+    enabled: bool
+    voice: str | None = None
+    language: str | None = None
+    auto_play: AutoPlay | None = None
+
+    @staticmethod
+    def builder() -> "TextToSpeechBuilder":
+        return TextToSpeechBuilder()
+
+
+class TextToSpeechBuilder:
+    def __init__(self):
+        self._text_to_speech = TextToSpeech(enabled=False)
+
+    def build(self) -> TextToSpeech:
+        return self._text_to_speech
+
+    def enabled(self, enabled: bool) -> "TextToSpeechBuilder":
+        self._text_to_speech.enabled = enabled
+        return self
+
+    def voice(self, voice: str) -> "TextToSpeechBuilder":
+        self._text_to_speech.voice = voice
+        return self
+
+    def language(self, language: str) -> "TextToSpeechBuilder":
+        self._text_to_speech.language = language
+        return self
+
+    def auto_play(self, auto_play: AutoPlay) -> "TextToSpeechBuilder":
+        self._text_to_speech.auto_play = auto_play
+        return self
+
+
+class RetrieverResource(BaseModel):
+    enabled: bool
+
+    @staticmethod
+    def builder() -> "RetrieverResourceBuilder":
+        return RetrieverResourceBuilder()
+
+
+class RetrieverResourceBuilder:
+    def __init__(self):
+        self._retriever_resource = RetrieverResource(enabled=False)
+
+    def build(self) -> RetrieverResource:
+        return self._retriever_resource
+
+    def enabled(self, enabled: bool) -> "RetrieverResourceBuilder":
+        self._retriever_resource.enabled = enabled
+        return self
+
+
+class AnnotationReply(BaseModel):
+    enabled: bool
+
+    @staticmethod
+    def builder() -> "AnnotationReplyBuilder":
+        return AnnotationReplyBuilder()
+
+
+class AnnotationReplyBuilder:
+    def __init__(self):
+        self._annotation_reply = AnnotationReply(enabled=False)
+
+    def build(self) -> AnnotationReply:
+        return self._annotation_reply
+
+    def enabled(self, enabled: bool) -> "AnnotationReplyBuilder":
+        self._annotation_reply.enabled = enabled
+        return self
+
+
+class ImageUpload(BaseModel):
+    enabled: bool
+    number_limits: int | None = None
+    detail: str | None = None
+    transfer_methods: list[TransferMethod] | None = None
+
+    @staticmethod
+    def builder() -> "ImageUploadBuilder":
+        return ImageUploadBuilder()
+
+
+class ImageUploadBuilder:
+    def __init__(self):
+        self._image_upload = ImageUpload(enabled=False)
+
+    def build(self) -> ImageUpload:
+        return self._image_upload
+
+    def enabled(self, enabled: bool) -> "ImageUploadBuilder":
+        self._image_upload.enabled = enabled
+        return self
+
+    def number_limits(self, number_limits: int) -> "ImageUploadBuilder":
+        self._image_upload.number_limits = number_limits
+        return self
+
+    def detail(self, detail: str) -> "ImageUploadBuilder":
+        self._image_upload.detail = detail
+        return self
+
+    def transfer_methods(self, transfer_methods: list[TransferMethod]) -> "ImageUploadBuilder":
+        self._image_upload.transfer_methods = transfer_methods
+        return self
+
+
+class FileUpload(BaseModel):
+    image: ImageUpload | None = None
+
+    @staticmethod
+    def builder() -> "FileUploadBuilder":
+        return FileUploadBuilder()
+
+
+class FileUploadBuilder:
+    def __init__(self):
+        self._file_upload = FileUpload()
+
+    def build(self) -> FileUpload:
+        return self._file_upload
+
+    def image(self, image: ImageUpload) -> "FileUploadBuilder":
+        self._file_upload.image = image
+        return self
+
+
+class SystemParameters(BaseModel):
+    file_size_limit: int | None = None
+    image_file_size_limit: int | None = None
+    audio_file_size_limit: int | None = None
+    video_file_size_limit: int | None = None
+
+    @staticmethod
+    def builder() -> "SystemParametersBuilder":
+        return SystemParametersBuilder()
+
+
+class SystemParametersBuilder:
+    def __init__(self):
+        self._system_parameters = SystemParameters()
+
+    def build(self) -> SystemParameters:
+        return self._system_parameters
+
+    def file_size_limit(self, file_size_limit: int) -> "SystemParametersBuilder":
+        self._system_parameters.file_size_limit = file_size_limit
+        return self
+
+    def image_file_size_limit(self, image_file_size_limit: int) -> "SystemParametersBuilder":
+        self._system_parameters.image_file_size_limit = image_file_size_limit
+        return self
+
+    def audio_file_size_limit(self, audio_file_size_limit: int) -> "SystemParametersBuilder":
+        self._system_parameters.audio_file_size_limit = audio_file_size_limit
+        return self
+
+    def video_file_size_limit(self, video_file_size_limit: int) -> "SystemParametersBuilder":
+        self._system_parameters.video_file_size_limit = video_file_size_limit
+        return self
+
+
+class AppParameters(BaseModel):
+    opening_statement: str | None = None
+    suggested_questions: list[str] | None = None
+    suggested_questions_after_answer: SuggestedQuestionsAfterAnswer | None = None
+    speech_to_text: SpeechToText | None = None
+    text_to_speech: TextToSpeech | None = None
+    retriever_resource: RetrieverResource | None = None
+    annotation_reply: AnnotationReply | None = None
+    user_input_form: list[UserInputFormItem] | None = None
+    file_upload: FileUpload | None = None
+    system_parameters: SystemParameters | None = None
+
+    @staticmethod
+    def builder() -> "AppParametersBuilder":
+        return AppParametersBuilder()
+
+
+class AppParametersBuilder:
+    def __init__(self):
+        self._app_parameters = AppParameters()
+
+    def build(self) -> AppParameters:
+        return self._app_parameters
+
+    def opening_statement(self, opening_statement: str) -> "AppParametersBuilder":
+        self._app_parameters.opening_statement = opening_statement
+        return self
+
+    def suggested_questions(self, suggested_questions: list[str]) -> "AppParametersBuilder":
+        self._app_parameters.suggested_questions = suggested_questions
+        return self
+
+    def suggested_questions_after_answer(
+        self, suggested_questions_after_answer: SuggestedQuestionsAfterAnswer
+    ) -> "AppParametersBuilder":
+        self._app_parameters.suggested_questions_after_answer = suggested_questions_after_answer
+        return self
+
+    def speech_to_text(self, speech_to_text: SpeechToText) -> "AppParametersBuilder":
+        self._app_parameters.speech_to_text = speech_to_text
+        return self
+
+    def text_to_speech(self, text_to_speech: TextToSpeech) -> "AppParametersBuilder":
+        self._app_parameters.text_to_speech = text_to_speech
+        return self
+
+    def retriever_resource(self, retriever_resource: RetrieverResource) -> "AppParametersBuilder":
+        self._app_parameters.retriever_resource = retriever_resource
+        return self
+
+    def annotation_reply(self, annotation_reply: AnnotationReply) -> "AppParametersBuilder":
+        self._app_parameters.annotation_reply = annotation_reply
+        return self
+
+    def user_input_form(self, user_input_form: list[UserInputFormItem]) -> "AppParametersBuilder":
+        self._app_parameters.user_input_form = user_input_form
+        return self
+
+    def file_upload(self, file_upload: FileUpload) -> "AppParametersBuilder":
+        self._app_parameters.file_upload = file_upload
+        return self
+
+    def system_parameters(self, system_parameters: SystemParameters) -> "AppParametersBuilder":
+        self._app_parameters.system_parameters = system_parameters
+        return self

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

@@ -0,0 +1,37 @@
+from io import BytesIO
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class AudioToTextRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.file: BytesIO | None = None
+        self.user: str | 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 file(self, file: BytesIO, file_name: str | None = None) -> "AudioToTextRequestBuilder":
+        self._audio_to_text_request.file = file
+        file_name = file_name or "audio"
+        self._audio_to_text_request.files = {"file": (file_name, file)}
+        return self
+
+    def user(self, user: str) -> "AudioToTextRequestBuilder":
+        self._audio_to_text_request.user = user
+        self._audio_to_text_request.body = {"user": user}
+        return self

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

@@ -0,0 +1,21 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class AudioToTextResponse(BaseResponse):
+    text: str | None = None
+
+    @staticmethod
+    def builder() -> "AudioToTextResponseBuilder":
+        return AudioToTextResponseBuilder()
+
+
+class AudioToTextResponseBuilder:
+    def __init__(self):
+        self._audio_to_text_response = AudioToTextResponse()
+
+    def build(self) -> AudioToTextResponse:
+        return self._audio_to_text_response
+
+    def text(self, text: str) -> "AudioToTextResponseBuilder":
+        self._audio_to_text_response.text = text
+        return self

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

@@ -0,0 +1,40 @@
+from pydantic import BaseModel
+
+from .chatflow_types import FileType, TransferMethod
+
+
+class ChatFile(BaseModel):
+    """File attachment model for chat messages."""
+
+    type: FileType | None = None
+    transfer_method: TransferMethod | None = None
+    url: str | None = None
+    upload_file_id: str | None = None
+
+    @staticmethod
+    def builder() -> "ChatFileBuilder":
+        return ChatFileBuilder()
+
+
+class ChatFileBuilder:
+    def __init__(self):
+        self._chat_file = ChatFile()
+
+    def build(self) -> ChatFile:
+        return self._chat_file
+
+    def type(self, type: FileType) -> "ChatFileBuilder":
+        self._chat_file.type = type
+        return self
+
+    def transfer_method(self, transfer_method: TransferMethod) -> "ChatFileBuilder":
+        self._chat_file.transfer_method = transfer_method
+        return self
+
+    def url(self, url: str) -> "ChatFileBuilder":
+        self._chat_file.url = url
+        return self
+
+    def upload_file_id(self, upload_file_id: str) -> "ChatFileBuilder":
+        self._chat_file.upload_file_id = upload_file_id
+        return self

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

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel
+
+from .chatflow_types import FeedbackRating, MessageFileBelongsTo
+from .retriever_resource import RetrieverResource
+
+if TYPE_CHECKING:
+    pass
+
+
+class MessageFile(BaseModel):
+    """Message file attachment model."""
+
+    id: str | None = None
+    type: str | None = None
+    url: str | None = None
+    belongs_to: MessageFileBelongsTo | None = None
+
+
+class MessageFeedback(BaseModel):
+    """Message feedback model."""
+
+    rating: FeedbackRating | None = None
+
+
+class ChatMessage(BaseModel):
+    """Core chat message model."""
+
+    id: str | None = None
+    conversation_id: str | None = None
+    inputs: dict[str, str] | None = None
+    query: str | None = None
+    answer: str | None = None
+    message_files: list[MessageFile] | None = None
+    feedback: MessageFeedback | None = None
+    retriever_resources: list[RetrieverResource] | None = None
+    created_at: int | None = None
+
+    @staticmethod
+    def builder() -> ChatMessageBuilder:
+        return ChatMessageBuilder()
+
+
+class ChatMessageBuilder:
+    def __init__(self):
+        self._chat_message = ChatMessage()
+
+    def build(self) -> ChatMessage:
+        return self._chat_message
+
+    def id(self, id: str) -> ChatMessageBuilder:
+        self._chat_message.id = id
+        return self
+
+    def conversation_id(self, conversation_id: str) -> ChatMessageBuilder:
+        self._chat_message.conversation_id = conversation_id
+        return self
+
+    def inputs(self, inputs: dict[str, str]) -> ChatMessageBuilder:
+        self._chat_message.inputs = inputs
+        return self
+
+    def query(self, query: str) -> ChatMessageBuilder:
+        self._chat_message.query = query
+        return self
+
+    def answer(self, answer: str) -> ChatMessageBuilder:
+        self._chat_message.answer = answer
+        return self
+
+    def message_files(self, message_files: list[MessageFile]) -> ChatMessageBuilder:
+        self._chat_message.message_files = message_files
+        return self
+
+    def feedback(self, feedback: MessageFeedback) -> ChatMessageBuilder:
+        self._chat_message.feedback = feedback
+        return self
+
+    def retriever_resources(self, retriever_resources: list[RetrieverResource]) -> ChatMessageBuilder:
+        self._chat_message.retriever_resources = retriever_resources
+        return self
+
+    def created_at(self, created_at: int) -> ChatMessageBuilder:
+        self._chat_message.created_at = created_at
+        return self