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

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

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

@@ -0,0 +1,55 @@
+from pydantic import BaseModel
+
+from .chatflow_types import VariableValueType
+
+
+class ConversationVariable(BaseModel):
+    """Conversation variable model."""
+
+    id: str | None = None
+    name: str | None = None
+    value_type: VariableValueType | None = None
+    value: str | None = None
+    description: str | None = None
+    created_at: int | None = None
+    updated_at: int | None = None
+
+    @staticmethod
+    def builder() -> "ConversationVariableBuilder":
+        return ConversationVariableBuilder()
+
+
+class ConversationVariableBuilder:
+    def __init__(self):
+        self._conversation_variable = ConversationVariable()
+
+    def build(self) -> ConversationVariable:
+        return self._conversation_variable
+
+    def id(self, id: str) -> "ConversationVariableBuilder":
+        self._conversation_variable.id = id
+        return self
+
+    def name(self, name: str) -> "ConversationVariableBuilder":
+        self._conversation_variable.name = name
+        return self
+
+    def value_type(self, value_type: VariableValueType) -> "ConversationVariableBuilder":
+        self._conversation_variable.value_type = value_type
+        return self
+
+    def value(self, value: str) -> "ConversationVariableBuilder":
+        self._conversation_variable.value = value
+        return self
+
+    def description(self, description: str) -> "ConversationVariableBuilder":
+        self._conversation_variable.description = description
+        return self
+
+    def created_at(self, created_at: int) -> "ConversationVariableBuilder":
+        self._conversation_variable.created_at = created_at
+        return self
+
+    def updated_at(self, updated_at: int) -> "ConversationVariableBuilder":
+        self._conversation_variable.updated_at = updated_at
+        return self

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

@@ -0,0 +1,30 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .create_annotation_request_body import CreateAnnotationRequestBody
+
+
+class CreateAnnotationRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.request_body: CreateAnnotationRequestBody | None = None
+
+    @staticmethod
+    def builder() -> "CreateAnnotationRequestBuilder":
+        return CreateAnnotationRequestBuilder()
+
+
+class CreateAnnotationRequestBuilder:
+    def __init__(self):
+        create_annotation_request = CreateAnnotationRequest()
+        create_annotation_request.http_method = HttpMethod.POST
+        create_annotation_request.uri = "/v1/apps/annotations"
+        self._create_annotation_request = create_annotation_request
+
+    def build(self) -> CreateAnnotationRequest:
+        return self._create_annotation_request
+
+    def request_body(self, request_body: CreateAnnotationRequestBody) -> "CreateAnnotationRequestBuilder":
+        self._create_annotation_request.request_body = request_body
+        self._create_annotation_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

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

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

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

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

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

@@ -0,0 +1,28 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class DeleteAnnotationRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.annotation_id: str | None = None
+
+    @staticmethod
+    def builder() -> "DeleteAnnotationRequestBuilder":
+        return DeleteAnnotationRequestBuilder()
+
+
+class DeleteAnnotationRequestBuilder:
+    def __init__(self):
+        delete_annotation_request = DeleteAnnotationRequest()
+        delete_annotation_request.http_method = HttpMethod.DELETE
+        delete_annotation_request.uri = "/v1/apps/annotations/:annotation_id"
+        self._delete_annotation_request = delete_annotation_request
+
+    def build(self) -> DeleteAnnotationRequest:
+        return self._delete_annotation_request
+
+    def annotation_id(self, annotation_id: str) -> "DeleteAnnotationRequestBuilder":
+        self._delete_annotation_request.annotation_id = annotation_id
+        self._delete_annotation_request.paths["annotation_id"] = annotation_id
+        return self

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

@@ -0,0 +1,7 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class DeleteAnnotationResponse(BaseResponse):
+    """Response for deleting annotation (No Content - 204)."""
+
+    pass

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

@@ -0,0 +1,36 @@
+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.request_body: DeleteConversationRequestBody | None = None
+        self.conversation_id: str | 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 build(self) -> DeleteConversationRequest:
+        return self._delete_conversation_request
+
+    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 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

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

@@ -0,0 +1,21 @@
+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 build(self) -> DeleteConversationRequestBody:
+        return self._delete_conversation_request_body
+
+    def user(self, user: str) -> "DeleteConversationRequestBodyBuilder":
+        self._delete_conversation_request_body.user = user
+        return self

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

@@ -0,0 +1,17 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class DeleteConversationResponse(BaseResponse):
+    """Response for delete conversation operation (No Content - 204)."""
+
+    @staticmethod
+    def builder() -> "DeleteConversationResponseBuilder":
+        return DeleteConversationResponseBuilder()
+
+
+class DeleteConversationResponseBuilder:
+    def __init__(self):
+        self._delete_conversation_response = DeleteConversationResponse()
+
+    def build(self) -> DeleteConversationResponse:
+        return self._delete_conversation_response

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

@@ -0,0 +1,75 @@
+from pydantic import BaseModel
+
+from .chatflow_types import FeedbackRating
+
+
+class FeedbackInfo(BaseModel):
+    """Feedback information model."""
+
+    id: str | None = None
+    app_id: str | None = None
+    conversation_id: str | None = None
+    message_id: str | None = None
+    rating: FeedbackRating | None = None
+    content: str | None = None
+    from_source: str | None = None
+    from_end_user_id: str | None = None
+    from_account_id: str | None = None
+    created_at: str | None = None
+    updated_at: str | None = None
+
+    @staticmethod
+    def builder() -> "FeedbackInfoBuilder":
+        return FeedbackInfoBuilder()
+
+
+class FeedbackInfoBuilder:
+    def __init__(self):
+        self._feedback_info = FeedbackInfo()
+
+    def build(self) -> FeedbackInfo:
+        return self._feedback_info
+
+    def id(self, id: str) -> "FeedbackInfoBuilder":
+        self._feedback_info.id = id
+        return self
+
+    def app_id(self, app_id: str) -> "FeedbackInfoBuilder":
+        self._feedback_info.app_id = app_id
+        return self
+
+    def conversation_id(self, conversation_id: str) -> "FeedbackInfoBuilder":
+        self._feedback_info.conversation_id = conversation_id
+        return self
+
+    def message_id(self, message_id: str) -> "FeedbackInfoBuilder":
+        self._feedback_info.message_id = message_id
+        return self
+
+    def rating(self, rating: FeedbackRating) -> "FeedbackInfoBuilder":
+        self._feedback_info.rating = rating
+        return self
+
+    def content(self, content: str) -> "FeedbackInfoBuilder":
+        self._feedback_info.content = content
+        return self
+
+    def from_source(self, from_source: str) -> "FeedbackInfoBuilder":
+        self._feedback_info.from_source = from_source
+        return self
+
+    def from_end_user_id(self, from_end_user_id: str) -> "FeedbackInfoBuilder":
+        self._feedback_info.from_end_user_id = from_end_user_id
+        return self
+
+    def from_account_id(self, from_account_id: str) -> "FeedbackInfoBuilder":
+        self._feedback_info.from_account_id = from_account_id
+        return self
+
+    def created_at(self, created_at: str) -> "FeedbackInfoBuilder":
+        self._feedback_info.created_at = created_at
+        return self
+
+    def updated_at(self, updated_at: str) -> "FeedbackInfoBuilder":
+        self._feedback_info.updated_at = updated_at
+        return self

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

@@ -0,0 +1,53 @@
+from pydantic import BaseModel
+
+
+class FileInfo(BaseModel):
+    """File information model."""
+
+    id: str | None = None
+    name: str | None = None
+    size: int | None = None
+    extension: str | None = None
+    mime_type: str | None = None
+    created_by: str | None = None
+    created_at: int | None = None
+
+    @staticmethod
+    def builder() -> "FileInfoBuilder":
+        return FileInfoBuilder()
+
+
+class FileInfoBuilder:
+    def __init__(self):
+        self._file_info = FileInfo()
+
+    def build(self) -> FileInfo:
+        return self._file_info
+
+    def id(self, id: str) -> "FileInfoBuilder":
+        self._file_info.id = id
+        return self
+
+    def name(self, name: str) -> "FileInfoBuilder":
+        self._file_info.name = name
+        return self
+
+    def size(self, size: int) -> "FileInfoBuilder":
+        self._file_info.size = size
+        return self
+
+    def extension(self, extension: str) -> "FileInfoBuilder":
+        self._file_info.extension = extension
+        return self
+
+    def mime_type(self, mime_type: str) -> "FileInfoBuilder":
+        self._file_info.mime_type = mime_type
+        return self
+
+    def created_by(self, created_by: str) -> "FileInfoBuilder":
+        self._file_info.created_by = created_by
+        return self
+
+    def created_at(self, created_at: int) -> "FileInfoBuilder":
+        self._file_info.created_at = created_at
+        return self

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

@@ -0,0 +1,30 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class GetAnnotationsRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def builder() -> "GetAnnotationsRequestBuilder":
+        return GetAnnotationsRequestBuilder()
+
+
+class GetAnnotationsRequestBuilder:
+    def __init__(self):
+        get_annotations_request = GetAnnotationsRequest()
+        get_annotations_request.http_method = HttpMethod.GET
+        get_annotations_request.uri = "/v1/apps/annotations"
+        self._get_annotations_request = get_annotations_request
+
+    def build(self) -> GetAnnotationsRequest:
+        return self._get_annotations_request
+
+    def page(self, page: int) -> "GetAnnotationsRequestBuilder":
+        self._get_annotations_request.add_query("page", page)
+        return self
+
+    def limit(self, limit: int) -> "GetAnnotationsRequestBuilder":
+        self._get_annotations_request.add_query("limit", limit)
+        return self

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

@@ -0,0 +1,13 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .annotation_info import AnnotationInfo
+
+
+class GetAnnotationsResponse(BaseResponse):
+    """Response for getting annotation list."""
+
+    data: list[AnnotationInfo] | None = None
+    has_more: bool | None = None
+    limit: int | None = None
+    total: int | None = None
+    page: int | None = None