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

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

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, HttpUrl
+
+from .chat_types import FileType, TransferMethod
+
+
+class ChatFile(BaseModel):
+    """Chat file model for file upload support."""
+
+    type: FileType | None = None
+    transfer_method: TransferMethod | None = None
+    url: HttpUrl | None = None
+    upload_file_id: str | None = None
+
+    @classmethod
+    def builder(cls) -> ChatFileBuilder:
+        return ChatFileBuilder()
+
+
+class ChatFileBuilder:
+    """Builder for ChatFile."""
+
+    def __init__(self) -> None:
+        self._chat_file = ChatFile()
+
+    def type(self, type_: FileType) -> ChatFileBuilder:
+        """Set file type."""
+        self._chat_file.type = type_
+        return self
+
+    def transfer_method(self, transfer_method: TransferMethod) -> ChatFileBuilder:
+        """Set transfer method."""
+        self._chat_file.transfer_method = transfer_method
+        return self
+
+    def url(self, url: str) -> ChatFileBuilder:
+        """Set remote URL."""
+        self._chat_file.url = HttpUrl(url=url)
+        return self
+
+    def upload_file_id(self, upload_file_id: str) -> ChatFileBuilder:
+        """Set upload file ID."""
+        self._chat_file.upload_file_id = upload_file_id
+        return self
+
+    def build(self) -> ChatFile:
+        """Build the ChatFile instance."""
+        if self._chat_file.transfer_method == "remote_url" and self._chat_file.url is None:
+            raise ValueError("URL is required when transfer_method is 'remote_url'")
+        if self._chat_file.transfer_method == "local_file" and self._chat_file.upload_file_id is None:
+            raise ValueError("upload_file_id is required when transfer_method is 'local_file'")
+        return self._chat_file

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

@@ -1,57 +1,70 @@
 from __future__ import annotations
 
+from typing import Any
+
 from pydantic import BaseModel
 
-from .chat_request_file import ChatRequestFile
+from .chat_file import ChatFile
+from .chat_types import ResponseMode
 
 
 class ChatRequestBody(BaseModel):
+    """Chat request body model."""
+
     query: str | None = None
-    inputs: dict | None = None
-    response_mode: str | None = None
+    inputs: dict[str, Any] | None = None
+    response_mode: ResponseMode | None = "streaming"
     user: str | None = None
     conversation_id: str | None = None
-    files: list[ChatRequestFile] | None = None
+    files: list[ChatFile] | None = None
     auto_generate_name: bool | None = None
 
-    @staticmethod
-    def builder() -> ChatRequestBodyBuilder:
+    @classmethod
+    def builder(cls) -> ChatRequestBodyBuilder:
         return ChatRequestBodyBuilder()
 
 
 class ChatRequestBodyBuilder:
-    def __init__(self):
+    """Builder for ChatRequestBody."""
+
+    def __init__(self) -> None:
         self._chat_request_body = ChatRequestBody()
 
     def query(self, query: str) -> ChatRequestBodyBuilder:
+        """Set user query."""
         self._chat_request_body.query = query
         return self
 
-    def inputs(self, inputs: dict) -> ChatRequestBodyBuilder:
+    def inputs(self, inputs: dict[str, Any]) -> ChatRequestBodyBuilder:
+        """Set input parameters."""
         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"')
+    def response_mode(self, response_mode: ResponseMode) -> ChatRequestBodyBuilder:
+        """Set response mode."""
         self._chat_request_body.response_mode = response_mode
         return self
 
     def user(self, user: str) -> ChatRequestBodyBuilder:
+        """Set user identifier."""
         self._chat_request_body.user = user
         return self
 
     def conversation_id(self, conversation_id: str) -> ChatRequestBodyBuilder:
+        """Set conversation ID."""
         self._chat_request_body.conversation_id = conversation_id
         return self
 
-    def files(self, files: list[ChatRequestFile]) -> ChatRequestBodyBuilder:
+    def files(self, files: list[ChatFile]) -> ChatRequestBodyBuilder:
+        """Set files."""
         self._chat_request_body.files = files
         return self
 
     def auto_generate_name(self, auto_generate_name: bool) -> ChatRequestBodyBuilder:
+        """Set auto generate name flag."""
         self._chat_request_body.auto_generate_name = auto_generate_name
         return self
 
-    def build(self):
+    def build(self) -> ChatRequestBody:
+        """Build the ChatRequestBody instance."""
         return self._chat_request_body

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

@@ -4,8 +4,16 @@ from pydantic import BaseModel
 
 from dify_oapi.core.model.base_response import BaseResponse
 
+from .retriever_resource import RetrieverResource
+from .usage_info import UsageInfo
+
 
 class ChatResponse(BaseResponse):
+    """Chat response model."""
+
+    event: str | None = None
+    task_id: str | None = None
+    id: str | None = None
     message_id: str | None = None
     conversation_id: str | None = None
     mode: str | None = None
@@ -15,5 +23,7 @@ class ChatResponse(BaseResponse):
 
 
 class ChatResponseMetadata(BaseModel):
-    usage: dict | None = None
-    retriever_resources: list[dict] | None = None
+    """Chat response metadata model."""
+
+    usage: UsageInfo | None = None
+    retriever_resources: list[RetrieverResource] | None = None

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

@@ -0,0 +1,65 @@
+"""Chat API type definitions for strict type safety."""
+
+from typing import Literal
+
+# Response mode types
+ResponseMode = Literal["streaming", "blocking"]
+
+# File types
+FileType = Literal["image"]
+
+# Transfer method types
+TransferMethod = Literal["remote_url", "local_file"]
+
+# Rating types
+Rating = Literal["like", "dislike"]
+
+# Sort types
+SortBy = Literal["created_at", "-created_at", "updated_at", "-updated_at"]
+
+# Icon types
+IconType = Literal["emoji", "image"]
+
+# Auto play types
+AutoPlay = Literal["enabled", "disabled"]
+
+# Annotation action types
+AnnotationAction = Literal["enable", "disable"]
+
+# Job status types
+JobStatus = Literal["waiting", "running", "completed", "failed"]
+
+# Message belongs to types
+MessageBelongsTo = Literal["user", "assistant"]
+
+# Conversation status types
+ConversationStatus = Literal["normal", "archived"]
+
+# Variable value types
+VariableValueType = Literal["string", "number", "select"]
+
+# Form input types
+FormInputType = Literal["text-input", "paragraph", "select"]
+
+# Streaming event types
+StreamingEventType = Literal[
+    "message",
+    "agent_message",
+    "tts_message",
+    "tts_message_end",
+    "agent_thought",
+    "message_file",
+    "message_end",
+    "message_replace",
+    "error",
+    "ping",
+]
+
+# Audio file formats
+AudioFormat = Literal["mp3", "mp4", "mpeg", "mpga", "m4a", "wav", "webm"]
+
+# Image file formats
+ImageFormat = Literal["png", "jpg", "jpeg", "webp", "gif"]
+
+# HTTP status codes
+HttpStatusCode = Literal[200, 204, 400, 401, 403, 404, 413, 415, 429, 500, 503]

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

@@ -0,0 +1,36 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .chat_types import AnnotationAction
+from .configure_annotation_reply_request_body import ConfigureAnnotationReplyRequestBody
+
+
+class ConfigureAnnotationReplyRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.request_body: ConfigureAnnotationReplyRequestBody | None = None
+
+    @staticmethod
+    def builder() -> "ConfigureAnnotationReplyRequestBuilder":
+        return ConfigureAnnotationReplyRequestBuilder()
+
+
+class ConfigureAnnotationReplyRequestBuilder:
+    def __init__(self) -> None:
+        configure_annotation_reply_request = ConfigureAnnotationReplyRequest()
+        configure_annotation_reply_request.http_method = HttpMethod.POST
+        configure_annotation_reply_request.uri = "/v1/apps/annotation-reply/:action"
+        self._configure_annotation_reply_request = configure_annotation_reply_request
+
+    def action(self, action: AnnotationAction) -> "ConfigureAnnotationReplyRequestBuilder":
+        self._configure_annotation_reply_request.paths["action"] = action
+        return self
+
+    def request_body(
+        self, request_body: ConfigureAnnotationReplyRequestBody
+    ) -> "ConfigureAnnotationReplyRequestBuilder":
+        self._configure_annotation_reply_request.request_body = request_body
+        return self
+
+    def build(self) -> ConfigureAnnotationReplyRequest:
+        return self._configure_annotation_reply_request

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

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class ConfigureAnnotationReplyRequestBody(BaseModel):
+    """Request body for configuring annotation reply settings."""
+
+    embedding_provider_name: str | None = None
+    embedding_model_name: str | None = None
+    score_threshold: float = 0.0
+
+    @staticmethod
+    def builder() -> ConfigureAnnotationReplyRequestBodyBuilder:
+        return ConfigureAnnotationReplyRequestBodyBuilder()
+
+
+class ConfigureAnnotationReplyRequestBodyBuilder:
+    """Builder for ConfigureAnnotationReplyRequestBody."""
+
+    def __init__(self):
+        self._configure_annotation_reply_request_body = ConfigureAnnotationReplyRequestBody()
+
+    def build(self) -> ConfigureAnnotationReplyRequestBody:
+        return self._configure_annotation_reply_request_body
+
+    def embedding_provider_name(
+        self, embedding_provider_name: str | None
+    ) -> ConfigureAnnotationReplyRequestBodyBuilder:
+        self._configure_annotation_reply_request_body.embedding_provider_name = embedding_provider_name
+        return self
+
+    def embedding_model_name(self, embedding_model_name: str | None) -> ConfigureAnnotationReplyRequestBodyBuilder:
+        self._configure_annotation_reply_request_body.embedding_model_name = embedding_model_name
+        return self
+
+    def score_threshold(self, score_threshold: float) -> ConfigureAnnotationReplyRequestBodyBuilder:
+        self._configure_annotation_reply_request_body.score_threshold = score_threshold
+        return self

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

@@ -0,0 +1,10 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .chat_types import JobStatus
+
+
+class ConfigureAnnotationReplyResponse(BaseResponse):
+    """Response for configuring annotation reply settings."""
+
+    job_id: str | None = None
+    job_status: JobStatus | None = None

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

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel
+
+from .chat_types import ConversationStatus
+
+
+class ConversationInfo(BaseModel):
+    id: str | None = None
+    name: str | None = None
+    inputs: dict[str, Any] | None = None
+    status: ConversationStatus | 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 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, Any]) -> ConversationInfoBuilder:
+        self._conversation_info.inputs = inputs
+        return self
+
+    def status(self, status: ConversationStatus) -> 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
+
+    def build(self) -> ConversationInfo:
+        return self._conversation_info

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

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .chat_types import VariableValueType
+
+
+class ConversationVariable(BaseModel):
+    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 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
+
+    def build(self) -> ConversationVariable:
+        return self._conversation_variable

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

@@ -0,0 +1,29 @@
+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) -> None:
+        super().__init__()
+        self.request_body: CreateAnnotationRequestBody | None = None
+
+    @staticmethod
+    def builder() -> "CreateAnnotationRequestBuilder":
+        return CreateAnnotationRequestBuilder()
+
+
+class CreateAnnotationRequestBuilder:
+    def __init__(self) -> None:
+        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 request_body(self, request_body: CreateAnnotationRequestBody) -> "CreateAnnotationRequestBuilder":
+        self._create_annotation_request.request_body = request_body
+        return self
+
+    def build(self) -> CreateAnnotationRequest:
+        return self._create_annotation_request

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

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class CreateAnnotationRequestBody(BaseModel):
+    """Request body for creating annotation."""
+
+    question: str = ""
+    answer: str = ""
+
+    @staticmethod
+    def builder() -> CreateAnnotationRequestBodyBuilder:
+        return CreateAnnotationRequestBodyBuilder()
+
+
+class CreateAnnotationRequestBodyBuilder:
+    """Builder for CreateAnnotationRequestBody."""
+
+    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/chat/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/chat/v1/model/delete_annotation_request.py

@@ -0,0 +1,26 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class DeleteAnnotationRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+
+    @staticmethod
+    def builder() -> "DeleteAnnotationRequestBuilder":
+        return DeleteAnnotationRequestBuilder()
+
+
+class DeleteAnnotationRequestBuilder:
+    def __init__(self) -> None:
+        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 annotation_id(self, annotation_id: str) -> "DeleteAnnotationRequestBuilder":
+        self._delete_annotation_request.paths["annotation_id"] = annotation_id
+        return self
+
+    def build(self) -> DeleteAnnotationRequest:
+        return self._delete_annotation_request

dify_oapi/api/chat/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 (204 No Content)."""
+
+    pass

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

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .chat_types import Rating
+
+
+class FeedbackInfo(BaseModel):
+    id: str | None = None
+    app_id: str | None = None
+    conversation_id: str | None = None
+    message_id: str | None = None
+    rating: Rating | 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 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: Rating) -> 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
+
+    def build(self) -> FeedbackInfo:
+        return self._feedback_info

dify_oapi/api/{workflow/v1/model/file → chat/v1/model}/file_info.py

@@ -1,9 +1,13 @@
+"""File information model for Chat API."""
+
 from __future__ import annotations
 
 from pydantic import BaseModel
 
 
 class FileInfo(BaseModel):
+    """File information model."""
+
     id: str | None = None
     name: str | None = None
     size: int | None = None
@@ -18,6 +22,8 @@ class FileInfo(BaseModel):
 
 
 class FileInfoBuilder:
+    """Builder for FileInfo."""
+
     def __init__(self):
         self._file_info = FileInfo()
 

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

@@ -0,0 +1,32 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .chat_types import AnnotationAction
+
+
+class GetAnnotationReplyStatusRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+
+    @staticmethod
+    def builder() -> "GetAnnotationReplyStatusRequestBuilder":
+        return GetAnnotationReplyStatusRequestBuilder()
+
+
+class GetAnnotationReplyStatusRequestBuilder:
+    def __init__(self) -> None:
+        get_annotation_reply_status_request = GetAnnotationReplyStatusRequest()
+        get_annotation_reply_status_request.http_method = HttpMethod.GET
+        get_annotation_reply_status_request.uri = "/v1/apps/annotation-reply/:action/status/:job_id"
+        self._get_annotation_reply_status_request = get_annotation_reply_status_request
+
+    def action(self, action: AnnotationAction) -> "GetAnnotationReplyStatusRequestBuilder":
+        self._get_annotation_reply_status_request.paths["action"] = action
+        return self
+
+    def job_id(self, job_id: str) -> "GetAnnotationReplyStatusRequestBuilder":
+        self._get_annotation_reply_status_request.paths["job_id"] = job_id
+        return self
+
+    def build(self) -> GetAnnotationReplyStatusRequest:
+        return self._get_annotation_reply_status_request