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

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

@@ -0,0 +1,64 @@
+"""Retriever resource model for Chat API."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class RetrieverResource(BaseModel):
+    """Retriever 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:
+    """Builder for RetrieverResource."""
+
+    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/chat/v1/model/site_settings.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .chat_types import IconType
+
+
+class SiteSettings(BaseModel):
+    """Site settings configuration."""
+
+    title: str | None = None
+    chat_color_theme: str | None = None
+    chat_color_theme_inverted: bool | None = None
+    icon_type: IconType | None = None
+    icon: str | None = None
+    icon_background: str | None = None
+    icon_url: str | None = None
+    description: str | None = None
+    copyright: str | None = None
+    privacy_policy: str | None = None
+    custom_disclaimer: str | None = None
+    default_language: str | None = None
+    show_workflow_steps: bool | None = None
+    use_icon_as_answer_icon: bool | None = None
+
+    @staticmethod
+    def builder() -> SiteSettingsBuilder:
+        return SiteSettingsBuilder()
+
+
+class SiteSettingsBuilder:
+    def __init__(self):
+        self._site_settings = SiteSettings()
+
+    def build(self) -> SiteSettings:
+        return self._site_settings
+
+    def title(self, title: str) -> SiteSettingsBuilder:
+        self._site_settings.title = title
+        return self
+
+    def chat_color_theme(self, chat_color_theme: str) -> SiteSettingsBuilder:
+        self._site_settings.chat_color_theme = chat_color_theme
+        return self
+
+    def chat_color_theme_inverted(self, chat_color_theme_inverted: bool) -> SiteSettingsBuilder:
+        self._site_settings.chat_color_theme_inverted = chat_color_theme_inverted
+        return self
+
+    def icon_type(self, icon_type: IconType) -> SiteSettingsBuilder:
+        self._site_settings.icon_type = icon_type
+        return self
+
+    def icon(self, icon: str) -> SiteSettingsBuilder:
+        self._site_settings.icon = icon
+        return self
+
+    def icon_background(self, icon_background: str) -> SiteSettingsBuilder:
+        self._site_settings.icon_background = icon_background
+        return self
+
+    def icon_url(self, icon_url: str) -> SiteSettingsBuilder:
+        self._site_settings.icon_url = icon_url
+        return self
+
+    def description(self, description: str) -> SiteSettingsBuilder:
+        self._site_settings.description = description
+        return self
+
+    def copyright(self, copyright: str) -> SiteSettingsBuilder:
+        self._site_settings.copyright = copyright
+        return self
+
+    def privacy_policy(self, privacy_policy: str) -> SiteSettingsBuilder:
+        self._site_settings.privacy_policy = privacy_policy
+        return self
+
+    def custom_disclaimer(self, custom_disclaimer: str) -> SiteSettingsBuilder:
+        self._site_settings.custom_disclaimer = custom_disclaimer
+        return self
+
+    def default_language(self, default_language: str) -> SiteSettingsBuilder:
+        self._site_settings.default_language = default_language
+        return self
+
+    def show_workflow_steps(self, show_workflow_steps: bool) -> SiteSettingsBuilder:
+        self._site_settings.show_workflow_steps = show_workflow_steps
+        return self
+
+    def use_icon_as_answer_icon(self, use_icon_as_answer_icon: bool) -> SiteSettingsBuilder:
+        self._site_settings.use_icon_as_answer_icon = use_icon_as_answer_icon
+        return self

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

@@ -0,0 +1,7 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class TextToAudioResponse(BaseResponse):
+    """Response for text-to-audio API that returns binary audio data."""
+
+    pass

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

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class ToolIconDetail(BaseModel):
+    """Tool icon detail configuration."""
+
+    background: str
+    content: str
+
+    @staticmethod
+    def builder() -> ToolIconDetailBuilder:
+        return ToolIconDetailBuilder()
+
+
+class ToolIconDetailBuilder:
+    def __init__(self):
+        self._tool_icon_detail = ToolIconDetail(background="", content="")
+
+    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 ToolIcon(BaseModel):
+    """Tool icon configuration."""
+
+    tool_icons: dict[str, str | ToolIconDetail] | None = None
+
+    @staticmethod
+    def builder() -> ToolIconBuilder:
+        return ToolIconBuilder()
+
+
+class ToolIconBuilder:
+    def __init__(self):
+        self._tool_icon = ToolIcon()
+
+    def build(self) -> ToolIcon:
+        return self._tool_icon
+
+    def tool_icons(self, tool_icons: dict[str, str | ToolIconDetail]) -> ToolIconBuilder:
+        self._tool_icon.tool_icons = tool_icons
+        return self

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

@@ -0,0 +1,34 @@
+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) -> None:
+        super().__init__()
+        self.request_body: UpdateAnnotationRequestBody | None = None
+
+    @staticmethod
+    def builder() -> "UpdateAnnotationRequestBuilder":
+        return UpdateAnnotationRequestBuilder()
+
+
+class UpdateAnnotationRequestBuilder:
+    def __init__(self) -> None:
+        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 annotation_id(self, annotation_id: str) -> "UpdateAnnotationRequestBuilder":
+        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
+
+    def build(self) -> UpdateAnnotationRequest:
+        return self._update_annotation_request

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

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class UpdateAnnotationRequestBody(BaseModel):
+    """Request body for updating annotation."""
+
+    question: str = ""
+    answer: str = ""
+
+    @staticmethod
+    def builder() -> UpdateAnnotationRequestBodyBuilder:
+        return UpdateAnnotationRequestBodyBuilder()
+
+
+class UpdateAnnotationRequestBodyBuilder:
+    """Builder for UpdateAnnotationRequestBody."""
+
+    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/chat/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/{completion/v1/model/file → chat/v1/model}/upload_file_request_body.py

@@ -1,10 +1,14 @@
+"""Upload file request body model."""
+
 from __future__ import annotations
 
 from pydantic import BaseModel
 
 
 class UploadFileRequestBody(BaseModel):
-    user: str | None = None
+    """Request body for upload file API."""
+
+    user: str
 
     @staticmethod
     def builder() -> UploadFileRequestBodyBuilder:
@@ -12,8 +16,10 @@ class UploadFileRequestBody(BaseModel):
 
 
 class UploadFileRequestBodyBuilder:
-    def __init__(self):
-        self._upload_file_request_body = UploadFileRequestBody()
+    """Builder for UploadFileRequestBody."""
+
+    def __init__(self) -> None:
+        self._upload_file_request_body = UploadFileRequestBody(user="")
 
     def build(self) -> UploadFileRequestBody:
         return self._upload_file_request_body

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

@@ -0,0 +1,84 @@
+"""Usage information model for Chat API."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class UsageInfo(BaseModel):
+    """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:
+    """Builder for UsageInfo."""
+
+    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

dify_oapi/api/chat/v1/resource/__init__.py

@@ -1,4 +1 @@
-from .chat import *  # noqa F403
-from .conversation import *  # noqa 403
-from .message import *  # noqa 403
-from .audio import *  # noqa 403
+

dify_oapi/api/chat/v1/resource/annotation.py

@@ -0,0 +1,87 @@
+from dify_oapi.core.http.transport import ATransport, Transport
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.request_option import RequestOption
+
+from ..model.configure_annotation_reply_request import ConfigureAnnotationReplyRequest
+from ..model.configure_annotation_reply_response import ConfigureAnnotationReplyResponse
+from ..model.create_annotation_request import CreateAnnotationRequest
+from ..model.create_annotation_response import CreateAnnotationResponse
+from ..model.delete_annotation_request import DeleteAnnotationRequest
+from ..model.delete_annotation_response import DeleteAnnotationResponse
+from ..model.get_annotation_reply_status_request import GetAnnotationReplyStatusRequest
+from ..model.get_annotation_reply_status_response import GetAnnotationReplyStatusResponse
+from ..model.list_annotations_request import ListAnnotationsRequest
+from ..model.list_annotations_response import ListAnnotationsResponse
+from ..model.update_annotation_request import UpdateAnnotationRequest
+from ..model.update_annotation_response import UpdateAnnotationResponse
+
+
+class Annotation:
+    def __init__(self, config: Config) -> None:
+        self.config = config
+
+    def list(self, request: ListAnnotationsRequest, request_option: RequestOption) -> ListAnnotationsResponse:
+        return Transport.execute(self.config, request, unmarshal_as=ListAnnotationsResponse, option=request_option)
+
+    async def alist(self, request: ListAnnotationsRequest, request_option: RequestOption) -> ListAnnotationsResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=ListAnnotationsResponse, option=request_option
+        )
+
+    def create(self, request: CreateAnnotationRequest, request_option: RequestOption) -> CreateAnnotationResponse:
+        return Transport.execute(self.config, request, unmarshal_as=CreateAnnotationResponse, option=request_option)
+
+    async def acreate(
+        self, request: CreateAnnotationRequest, request_option: RequestOption
+    ) -> CreateAnnotationResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=CreateAnnotationResponse, option=request_option
+        )
+
+    def update(self, request: UpdateAnnotationRequest, request_option: RequestOption) -> UpdateAnnotationResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateAnnotationResponse, option=request_option)
+
+    async def aupdate(
+        self, request: UpdateAnnotationRequest, request_option: RequestOption
+    ) -> UpdateAnnotationResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=UpdateAnnotationResponse, option=request_option
+        )
+
+    def delete(self, request: DeleteAnnotationRequest, request_option: RequestOption) -> DeleteAnnotationResponse:
+        return Transport.execute(self.config, request, unmarshal_as=DeleteAnnotationResponse, option=request_option)
+
+    async def adelete(
+        self, request: DeleteAnnotationRequest, request_option: RequestOption
+    ) -> DeleteAnnotationResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=DeleteAnnotationResponse, option=request_option
+        )
+
+    def configure(
+        self, request: ConfigureAnnotationReplyRequest, request_option: RequestOption
+    ) -> ConfigureAnnotationReplyResponse:
+        return Transport.execute(
+            self.config, request, unmarshal_as=ConfigureAnnotationReplyResponse, option=request_option
+        )
+
+    async def aconfigure(
+        self, request: ConfigureAnnotationReplyRequest, request_option: RequestOption
+    ) -> ConfigureAnnotationReplyResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=ConfigureAnnotationReplyResponse, option=request_option
+        )
+
+    def status(
+        self, request: GetAnnotationReplyStatusRequest, request_option: RequestOption
+    ) -> GetAnnotationReplyStatusResponse:
+        return Transport.execute(
+            self.config, request, unmarshal_as=GetAnnotationReplyStatusResponse, option=request_option
+        )
+
+    async def astatus(
+        self, request: GetAnnotationReplyStatusRequest, request_option: RequestOption
+    ) -> GetAnnotationReplyStatusResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetAnnotationReplyStatusResponse, option=request_option
+        )

dify_oapi/api/chat/v1/resource/chat.py

@@ -7,62 +7,84 @@ from dify_oapi.core.model.request_option import RequestOption
 
 from ..model.chat_request import ChatRequest
 from ..model.chat_response import ChatResponse
+from ..model.get_suggested_questions_request import GetSuggestedQuestionsRequest
+from ..model.get_suggested_questions_response import GetSuggestedQuestionsResponse
 from ..model.stop_chat_request import StopChatRequest
 from ..model.stop_chat_response import StopChatResponse
 
 
 class Chat:
     def __init__(self, config: Config) -> None:
-        self.config: Config = config
+        self.config = config
 
     @overload
     def chat(
-        self, request: ChatRequest, option: RequestOption | None, stream: Literal[True]
+        self,
+        request: ChatRequest,
+        request_option: RequestOption,
+        stream: Literal[True],
     ) -> Generator[bytes, None, None]: ...
 
     @overload
-    def chat(self, request: ChatRequest, option: RequestOption | None, stream: Literal[False]) -> ChatResponse: ...
-
-    @overload
-    def chat(self, request: ChatRequest, option: RequestOption | None) -> ChatResponse: ...
+    def chat(
+        self,
+        request: ChatRequest,
+        request_option: RequestOption,
+        stream: Literal[False] = False,
+    ) -> ChatResponse: ...
 
     def chat(
         self,
         request: ChatRequest,
-        option: RequestOption | None = None,
+        request_option: RequestOption,
         stream: bool = False,
-    ):
+    ) -> ChatResponse | Generator[bytes, None, None]:
         if stream:
-            return Transport.execute(self.config, request, option=option, stream=True)
-        else:
-            return Transport.execute(self.config, request, unmarshal_as=ChatResponse, option=option)
+            return Transport.execute(self.config, request, stream=True, option=request_option)
+        return Transport.execute(self.config, request, unmarshal_as=ChatResponse, option=request_option)
 
     @overload
     async def achat(
-        self, request: ChatRequest, option: RequestOption | None, stream: Literal[True]
+        self,
+        request: ChatRequest,
+        request_option: RequestOption,
+        stream: Literal[True],
     ) -> AsyncGenerator[bytes, None]: ...
 
     @overload
     async def achat(
-        self, request: ChatRequest, option: RequestOption | None, stream: Literal[False]
+        self,
+        request: ChatRequest,
+        request_option: RequestOption,
+        stream: Literal[False] = False,
     ) -> ChatResponse: ...
 
-    @overload
-    async def achat(self, request: ChatRequest, option: RequestOption | None) -> ChatResponse: ...
-
     async def achat(
         self,
         request: ChatRequest,
-        option: RequestOption | None = None,
+        request_option: RequestOption,
         stream: bool = False,
-    ):
+    ) -> ChatResponse | AsyncGenerator[bytes, None]:
         if stream:
-            return await ATransport.aexecute(self.config, request, option=option, stream=True)
-        else:
-            return await ATransport.aexecute(self.config, request, unmarshal_as=ChatResponse, option=option)
+            return await ATransport.aexecute(self.config, request, stream=True, option=request_option)
+        return await ATransport.aexecute(self.config, request, unmarshal_as=ChatResponse, option=request_option)
+
+    def stop(self, request: StopChatRequest, request_option: RequestOption) -> StopChatResponse:
+        return Transport.execute(self.config, request, unmarshal_as=StopChatResponse, option=request_option)
+
+    async def astop(self, request: StopChatRequest, request_option: RequestOption) -> StopChatResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=StopChatResponse, option=request_option)
 
-    def stop(self, request: StopChatRequest, option: RequestOption | None = None) -> StopChatResponse:
-        return Transport.execute(self.config, request, unmarshal_as=StopChatResponse, option=option)
+    def suggested(
+        self, request: GetSuggestedQuestionsRequest, request_option: RequestOption
+    ) -> GetSuggestedQuestionsResponse:
+        return Transport.execute(
+            self.config, request, unmarshal_as=GetSuggestedQuestionsResponse, option=request_option
+        )
 
-    async def astop(self, request: StopChatRequest, option: RequestOption | None = None) -> StopChatResponse:
-        return await ATransport.aexecute(self.config, request, unmarshal_as=StopChatResponse, option=option)
+    async def asuggested(
+        self, request: GetSuggestedQuestionsRequest, request_option: RequestOption
+    ) -> GetSuggestedQuestionsResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetSuggestedQuestionsResponse, option=request_option
+        )