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

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/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

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

@@ -0,0 +1,210 @@
+"""Strict type definitions for all Chatflow API enums and constants.
+
+This module defines all Literal types used throughout the Chatflow API
+to ensure type safety and prevent invalid values.
+"""
+
+from typing import Literal
+
+# Response mode types for chat messages
+ResponseMode = Literal["streaming", "blocking"]
+"""Response mode for chat messages. 
+- streaming: Real-time streaming response
+- blocking: Complete response after processing (Cloudflare timeout is 100s)
+"""
+
+# File types for file attachments
+FileType = Literal["document", "image", "audio", "video", "custom"]
+"""File type for attachments.
+- document: TXT, MD, PDF, HTML, XLSX, DOCX, CSV, EML, MSG, PPTX, XML, EPUB
+- image: JPG, PNG, GIF, WEBP, SVG
+- audio: MP3, M4A, WAV, WEBM, AMR
+- video: MP4, MOV, MPEG, MPGA
+- custom: Custom file type
+"""
+
+# Transfer method types for file handling
+TransferMethod = Literal["remote_url", "local_file"]
+"""Transfer method for file handling.
+- remote_url: File URL for remote files
+- local_file: File upload for local files
+"""
+
+# Stream event types for real-time responses
+StreamEvent = Literal[
+    "message",
+    "message_file",
+    "message_end",
+    "tts_message",
+    "tts_message_end",
+    "message_replace",
+    "workflow_started",
+    "node_started",
+    "node_finished",
+    "workflow_finished",
+    "error",
+    "ping",
+]
+"""Stream event types for real-time chat responses.
+- message: Chat message content chunk
+- message_file: File attachment information
+- message_end: End of message with metadata
+- tts_message: Text-to-speech audio chunk (Base64 encoded)
+- tts_message_end: End of TTS conversion
+- message_replace: Replace previous message content
+- workflow_started: Workflow execution started
+- node_started: Workflow node execution started
+- node_finished: Workflow node execution finished
+- workflow_finished: Workflow execution completed
+- error: Error occurred during processing
+- ping: Keep-alive ping
+"""
+
+# Message file belongs to types
+MessageFileBelongsTo = Literal["user", "assistant"]
+"""Message file ownership.
+- user: File belongs to user
+- assistant: File belongs to assistant
+"""
+
+# Feedback rating types
+FeedbackRating = Literal["like", "dislike"]
+"""Feedback rating types.
+- like: Positive feedback
+- dislike: Negative feedback
+"""
+
+# Sort by types for conversation listing
+SortBy = Literal["created_at", "-created_at", "updated_at", "-updated_at"]
+"""Sort by options for conversation listing.
+- created_at: Sort by creation time (ascending)
+- -created_at: Sort by creation time (descending)
+- updated_at: Sort by update time (ascending)
+- -updated_at: Sort by update time (descending)
+"""
+
+# Conversation status types
+ConversationStatus = Literal["normal", "archived"]
+"""Conversation status types.
+- normal: Active conversation
+- archived: Archived conversation
+"""
+
+# Variable value types
+VariableValueType = Literal["string", "number", "select"]
+"""Variable value types for conversation variables.
+- string: String value
+- number: Numeric value
+- select: Selection value
+"""
+
+# Form input types for user input forms
+FormInputType = Literal["text-input", "paragraph", "select"]
+"""Form input types for user input forms.
+- text-input: Single line text input
+- paragraph: Multi-line text input
+- select: Selection dropdown
+"""
+
+# Job status types for annotation operations
+JobStatus = Literal["waiting", "running", "completed", "failed"]
+"""Job status types for annotation operations.
+- waiting: Job is waiting to start
+- running: Job is currently running
+- completed: Job completed successfully
+- failed: Job failed with error
+"""
+
+# Audio format types for TTS operations
+AudioFormat = Literal["mp3", "mp4", "mpeg", "mpga", "m4a", "wav", "webm"]
+"""Audio format types for TTS operations.
+- mp3: MP3 audio format
+- mp4: MP4 audio format
+- mpeg: MPEG audio format
+- mpga: MPGA audio format
+- m4a: M4A audio format
+- wav: WAV audio format
+- webm: WebM audio format
+"""
+
+# Language codes for internationalization
+LanguageCode = Literal["en", "zh", "ja", "ko", "es", "fr", "de", "it", "pt", "ru"]
+"""Language codes for internationalization.
+- en: English
+- zh: Chinese
+- ja: Japanese
+- ko: Korean
+- es: Spanish
+- fr: French
+- de: German
+- it: Italian
+- pt: Portuguese
+- ru: Russian
+"""
+
+# Chat color theme types
+ChatColorTheme = Literal["blue", "green", "purple", "orange", "red"]
+"""Chat color theme types for UI customization.
+- blue: Blue theme
+- green: Green theme
+- purple: Purple theme
+- orange: Orange theme
+- red: Red theme
+"""
+
+# Default language types for application settings
+DefaultLanguage = Literal[
+    "en-US", "zh-Hans", "zh-Hant", "ja-JP", "ko-KR", "es-ES", "fr-FR", "de-DE", "it-IT", "pt-BR", "ru-RU"
+]
+"""Default language types for application settings.
+- en-US: English (United States)
+- zh-Hans: Chinese (Simplified)
+- zh-Hant: Chinese (Traditional)
+- ja-JP: Japanese (Japan)
+- ko-KR: Korean (Korea)
+- es-ES: Spanish (Spain)
+- fr-FR: French (France)
+- de-DE: German (Germany)
+- it-IT: Italian (Italy)
+- pt-BR: Portuguese (Brazil)
+- ru-RU: Russian (Russia)
+"""
+
+# Icon types for application settings
+IconType = Literal["emoji", "image"]
+"""Icon types for application settings.
+- emoji: Emoji icon
+- image: Image icon
+"""
+
+# AutoPlay types for TTS settings
+AutoPlay = Literal["enabled", "disabled"]
+"""AutoPlay types for TTS settings.
+- enabled: Auto-play enabled
+- disabled: Auto-play disabled
+"""
+
+# Annotation action types
+AnnotationAction = Literal["enable", "disable"]
+"""Annotation action types for reply settings.
+- enable: Enable annotation reply
+- disable: Disable annotation reply
+"""
+
+# Node status types for workflow operations
+NodeStatus = Literal["running", "succeeded", "failed", "stopped"]
+"""Node status types for workflow operations.
+- running: Node is currently running
+- succeeded: Node completed successfully
+- failed: Node failed with error
+- stopped: Node was stopped
+"""
+
+# Workflow status types
+WorkflowStatus = Literal["running", "succeeded", "failed", "stopped"]
+"""Workflow status types.
+- running: Workflow is currently running
+- succeeded: Workflow completed successfully
+- failed: Workflow failed with error
+- stopped: Workflow was stopped
+"""

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

@@ -0,0 +1,53 @@
+from pydantic import BaseModel
+
+
+class ConversationInfo(BaseModel):
+    """Conversation information model."""
+
+    id: str | None = None
+    name: str | None = None
+    inputs: dict[str, str] | None = None
+    status: str | None = None
+    introduction: str | None = None
+    created_at: int | None = None
+    updated_at: int | None = None
+
+    @staticmethod
+    def builder() -> "ConversationInfoBuilder":
+        return ConversationInfoBuilder()
+
+
+class ConversationInfoBuilder:
+    def __init__(self):
+        self._conversation_info = ConversationInfo()
+
+    def build(self) -> ConversationInfo:
+        return self._conversation_info
+
+    def id(self, id: str) -> "ConversationInfoBuilder":
+        self._conversation_info.id = id
+        return self
+
+    def name(self, name: str) -> "ConversationInfoBuilder":
+        self._conversation_info.name = name
+        return self
+
+    def inputs(self, inputs: dict[str, str]) -> "ConversationInfoBuilder":
+        self._conversation_info.inputs = inputs
+        return self
+
+    def status(self, status: str) -> "ConversationInfoBuilder":
+        self._conversation_info.status = status
+        return self
+
+    def introduction(self, introduction: str) -> "ConversationInfoBuilder":
+        self._conversation_info.introduction = introduction
+        return self
+
+    def created_at(self, created_at: int) -> "ConversationInfoBuilder":
+        self._conversation_info.created_at = created_at
+        return self
+
+    def updated_at(self, updated_at: int) -> "ConversationInfoBuilder":
+        self._conversation_info.updated_at = updated_at
+        return self