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

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

@@ -0,0 +1,32 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class GetSuggestedQuestionsRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.message_id: str | None = None
+
+    @staticmethod
+    def builder() -> "GetSuggestedQuestionsRequestBuilder":
+        return GetSuggestedQuestionsRequestBuilder()
+
+
+class GetSuggestedQuestionsRequestBuilder:
+    def __init__(self):
+        get_suggested_questions_request = GetSuggestedQuestionsRequest()
+        get_suggested_questions_request.http_method = HttpMethod.GET
+        get_suggested_questions_request.uri = "/v1/messages/:message_id/suggested"
+        self._get_suggested_questions_request = get_suggested_questions_request
+
+    def build(self) -> GetSuggestedQuestionsRequest:
+        return self._get_suggested_questions_request
+
+    def message_id(self, message_id: str) -> "GetSuggestedQuestionsRequestBuilder":
+        self._get_suggested_questions_request.message_id = message_id
+        self._get_suggested_questions_request.paths["message_id"] = message_id
+        return self
+
+    def user(self, user: str) -> "GetSuggestedQuestionsRequestBuilder":
+        self._get_suggested_questions_request.add_query("user", user)
+        return self

dify_oapi/api/{completion/v1/model/feedback/message_feedback_response.py → chatflow/v1/model/get_suggested_questions_response.py}

@@ -1,7 +1,6 @@
-from __future__ import annotations
-
 from dify_oapi.core.model.base_response import BaseResponse
 
 
-class MessageFeedbackResponse(BaseResponse):
+class GetSuggestedQuestionsResponse(BaseResponse):
     result: str | None = None
+    data: list[str] | None = None

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

@@ -0,0 +1,36 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .rename_conversation_request_body import RenameConversationRequestBody
+
+
+class RenameConversationRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.request_body: RenameConversationRequestBody | None = None
+        self.conversation_id: str | None = None
+
+    @staticmethod
+    def builder() -> "RenameConversationRequestBuilder":
+        return RenameConversationRequestBuilder()
+
+
+class RenameConversationRequestBuilder:
+    def __init__(self):
+        rename_conversation_request = RenameConversationRequest()
+        rename_conversation_request.http_method = HttpMethod.POST
+        rename_conversation_request.uri = "/v1/conversations/:conversation_id/name"
+        self._rename_conversation_request = rename_conversation_request
+
+    def build(self) -> RenameConversationRequest:
+        return self._rename_conversation_request
+
+    def conversation_id(self, conversation_id: str) -> "RenameConversationRequestBuilder":
+        self._rename_conversation_request.conversation_id = conversation_id
+        self._rename_conversation_request.paths["conversation_id"] = conversation_id
+        return self
+
+    def request_body(self, request_body: RenameConversationRequestBody) -> "RenameConversationRequestBuilder":
+        self._rename_conversation_request.request_body = request_body
+        self._rename_conversation_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

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

@@ -0,0 +1,31 @@
+from pydantic import BaseModel
+
+
+class RenameConversationRequestBody(BaseModel):
+    name: str | None = None
+    auto_generate: bool | None = None
+    user: str | None = None
+
+    @staticmethod
+    def builder() -> "RenameConversationRequestBodyBuilder":
+        return RenameConversationRequestBodyBuilder()
+
+
+class RenameConversationRequestBodyBuilder:
+    def __init__(self):
+        self._rename_conversation_request_body = RenameConversationRequestBody()
+
+    def build(self) -> RenameConversationRequestBody:
+        return self._rename_conversation_request_body
+
+    def name(self, name: str) -> "RenameConversationRequestBodyBuilder":
+        self._rename_conversation_request_body.name = name
+        return self
+
+    def auto_generate(self, auto_generate: bool) -> "RenameConversationRequestBodyBuilder":
+        self._rename_conversation_request_body.auto_generate = auto_generate
+        return self
+
+    def user(self, user: str) -> "RenameConversationRequestBodyBuilder":
+        self._rename_conversation_request_body.user = user
+        return self

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

@@ -0,0 +1,53 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class RenameConversationResponse(BaseResponse):
+    """Response for rename conversation operation with updated conversation info."""
+
+    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() -> "RenameConversationResponseBuilder":
+        return RenameConversationResponseBuilder()
+
+
+class RenameConversationResponseBuilder:
+    def __init__(self):
+        self._rename_conversation_response = RenameConversationResponse()
+
+    def build(self) -> RenameConversationResponse:
+        return self._rename_conversation_response
+
+    def id(self, id: str) -> "RenameConversationResponseBuilder":
+        self._rename_conversation_response.id = id
+        return self
+
+    def name(self, name: str) -> "RenameConversationResponseBuilder":
+        self._rename_conversation_response.name = name
+        return self
+
+    def inputs(self, inputs: dict[str, str]) -> "RenameConversationResponseBuilder":
+        self._rename_conversation_response.inputs = inputs
+        return self
+
+    def status(self, status: str) -> "RenameConversationResponseBuilder":
+        self._rename_conversation_response.status = status
+        return self
+
+    def introduction(self, introduction: str) -> "RenameConversationResponseBuilder":
+        self._rename_conversation_response.introduction = introduction
+        return self
+
+    def created_at(self, created_at: int) -> "RenameConversationResponseBuilder":
+        self._rename_conversation_response.created_at = created_at
+        return self
+
+    def updated_at(self, updated_at: int) -> "RenameConversationResponseBuilder":
+        self._rename_conversation_response.updated_at = updated_at
+        return self

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/{dify/v1/model/message_feedback_response.py → chatflow/v1/model/stop_chat_message_response.py}

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

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