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

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

@@ -0,0 +1,141 @@
+from pydantic import BaseModel
+
+
+class TextInputControl(BaseModel):
+    label: str
+    variable: str
+    required: bool
+    default: str | None = None
+
+    @staticmethod
+    def builder() -> "TextInputControlBuilder":
+        return TextInputControlBuilder()
+
+
+class TextInputControlBuilder:
+    def __init__(self):
+        self._text_input_control = TextInputControl(label="", variable="", required=False)
+
+    def build(self) -> TextInputControl:
+        return self._text_input_control
+
+    def label(self, label: str) -> "TextInputControlBuilder":
+        self._text_input_control.label = label
+        return self
+
+    def variable(self, variable: str) -> "TextInputControlBuilder":
+        self._text_input_control.variable = variable
+        return self
+
+    def required(self, required: bool) -> "TextInputControlBuilder":
+        self._text_input_control.required = required
+        return self
+
+    def default(self, default: str) -> "TextInputControlBuilder":
+        self._text_input_control.default = default
+        return self
+
+
+class ParagraphControl(BaseModel):
+    label: str
+    variable: str
+    required: bool
+    default: str | None = None
+
+    @staticmethod
+    def builder() -> "ParagraphControlBuilder":
+        return ParagraphControlBuilder()
+
+
+class ParagraphControlBuilder:
+    def __init__(self):
+        self._paragraph_control = ParagraphControl(label="", variable="", required=False)
+
+    def build(self) -> ParagraphControl:
+        return self._paragraph_control
+
+    def label(self, label: str) -> "ParagraphControlBuilder":
+        self._paragraph_control.label = label
+        return self
+
+    def variable(self, variable: str) -> "ParagraphControlBuilder":
+        self._paragraph_control.variable = variable
+        return self
+
+    def required(self, required: bool) -> "ParagraphControlBuilder":
+        self._paragraph_control.required = required
+        return self
+
+    def default(self, default: str) -> "ParagraphControlBuilder":
+        self._paragraph_control.default = default
+        return self
+
+
+class SelectControl(BaseModel):
+    label: str
+    variable: str
+    required: bool
+    default: str | None = None
+    options: list[str]
+
+    @staticmethod
+    def builder() -> "SelectControlBuilder":
+        return SelectControlBuilder()
+
+
+class SelectControlBuilder:
+    def __init__(self):
+        self._select_control = SelectControl(label="", variable="", required=False, options=[])
+
+    def build(self) -> SelectControl:
+        return self._select_control
+
+    def label(self, label: str) -> "SelectControlBuilder":
+        self._select_control.label = label
+        return self
+
+    def variable(self, variable: str) -> "SelectControlBuilder":
+        self._select_control.variable = variable
+        return self
+
+    def required(self, required: bool) -> "SelectControlBuilder":
+        self._select_control.required = required
+        return self
+
+    def default(self, default: str) -> "SelectControlBuilder":
+        self._select_control.default = default
+        return self
+
+    def options(self, options: list[str]) -> "SelectControlBuilder":
+        self._select_control.options = options
+        return self
+
+
+class UserInputFormItem(BaseModel):
+    text_input: TextInputControl | None = None
+    paragraph: ParagraphControl | None = None
+    select: SelectControl | None = None
+
+    @staticmethod
+    def builder() -> "UserInputFormItemBuilder":
+        return UserInputFormItemBuilder()
+
+
+class UserInputFormItemBuilder:
+    def __init__(self):
+        self._user_input_form_item = UserInputFormItem()
+
+    def build(self) -> UserInputFormItem:
+        return self._user_input_form_item
+
+    def text_input(self, text_input: TextInputControl) -> "UserInputFormItemBuilder":
+        self._user_input_form_item.text_input = text_input
+        return self
+
+    def paragraph(self, paragraph: ParagraphControl) -> "UserInputFormItemBuilder":
+        self._user_input_form_item.paragraph = paragraph
+        return self
+
+    def select(self, select: SelectControl) -> "UserInputFormItemBuilder":
+        self._user_input_form_item.select = select
+        return self

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

@@ -0,0 +1,88 @@
+from pydantic import BaseModel
+
+from .chatflow_types import ChatColorTheme, DefaultLanguage, IconType
+
+
+class WebAppSettings(BaseModel):
+    title: str | None = None
+    chat_color_theme: ChatColorTheme | 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: DefaultLanguage | None = None
+    show_workflow_steps: bool | None = None
+    use_icon_as_answer_icon: bool | None = None
+
+    @staticmethod
+    def builder() -> "WebAppSettingsBuilder":
+        return WebAppSettingsBuilder()
+
+
+class WebAppSettingsBuilder:
+    def __init__(self):
+        self._webapp_settings = WebAppSettings()
+
+    def build(self) -> WebAppSettings:
+        return self._webapp_settings
+
+    def title(self, title: str) -> "WebAppSettingsBuilder":
+        self._webapp_settings.title = title
+        return self
+
+    def chat_color_theme(self, chat_color_theme: ChatColorTheme) -> "WebAppSettingsBuilder":
+        self._webapp_settings.chat_color_theme = chat_color_theme
+        return self
+
+    def chat_color_theme_inverted(self, chat_color_theme_inverted: bool) -> "WebAppSettingsBuilder":
+        self._webapp_settings.chat_color_theme_inverted = chat_color_theme_inverted
+        return self
+
+    def icon_type(self, icon_type: IconType) -> "WebAppSettingsBuilder":
+        self._webapp_settings.icon_type = icon_type
+        return self
+
+    def icon(self, icon: str) -> "WebAppSettingsBuilder":
+        self._webapp_settings.icon = icon
+        return self
+
+    def icon_background(self, icon_background: str) -> "WebAppSettingsBuilder":
+        self._webapp_settings.icon_background = icon_background
+        return self
+
+    def icon_url(self, icon_url: str) -> "WebAppSettingsBuilder":
+        self._webapp_settings.icon_url = icon_url
+        return self
+
+    def description(self, description: str) -> "WebAppSettingsBuilder":
+        self._webapp_settings.description = description
+        return self
+
+    def copyright(self, copyright: str) -> "WebAppSettingsBuilder":
+        self._webapp_settings.copyright = copyright
+        return self
+
+    def privacy_policy(self, privacy_policy: str) -> "WebAppSettingsBuilder":
+        self._webapp_settings.privacy_policy = privacy_policy
+        return self
+
+    def custom_disclaimer(self, custom_disclaimer: str) -> "WebAppSettingsBuilder":
+        self._webapp_settings.custom_disclaimer = custom_disclaimer
+        return self
+
+    def default_language(self, default_language: DefaultLanguage) -> "WebAppSettingsBuilder":
+        self._webapp_settings.default_language = default_language
+        return self
+
+    def show_workflow_steps(self, show_workflow_steps: bool) -> "WebAppSettingsBuilder":
+        self._webapp_settings.show_workflow_steps = show_workflow_steps
+        return self
+
+    def use_icon_as_answer_icon(self, use_icon_as_answer_icon: bool) -> "WebAppSettingsBuilder":
+        self._webapp_settings.use_icon_as_answer_icon = use_icon_as_answer_icon
+        return self

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

@@ -0,0 +1,122 @@
+from dify_oapi.core.http.transport.async_transport import ATransport
+from dify_oapi.core.http.transport.sync_transport import Transport
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.request_option import RequestOption
+
+from ..model.annotation_reply_settings_request import AnnotationReplySettingsRequest
+from ..model.annotation_reply_settings_response import AnnotationReplySettingsResponse
+from ..model.annotation_reply_status_request import AnnotationReplyStatusRequest
+from ..model.annotation_reply_status_response import AnnotationReplyStatusResponse
+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_annotations_request import GetAnnotationsRequest
+from ..model.get_annotations_response import GetAnnotationsResponse
+from ..model.update_annotation_request import UpdateAnnotationRequest
+from ..model.update_annotation_response import UpdateAnnotationResponse
+
+
+class Annotation:
+    def __init__(self, config: Config):
+        self.config = config
+
+    def list(
+        self,
+        request: GetAnnotationsRequest,
+        request_option: RequestOption,
+    ) -> GetAnnotationsResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetAnnotationsResponse, option=request_option)
+
+    async def alist(
+        self,
+        request: GetAnnotationsRequest,
+        request_option: RequestOption,
+    ) -> GetAnnotationsResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetAnnotationsResponse, 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 reply_settings(
+        self,
+        request: AnnotationReplySettingsRequest,
+        request_option: RequestOption,
+    ) -> AnnotationReplySettingsResponse:
+        return Transport.execute(
+            self.config, request, unmarshal_as=AnnotationReplySettingsResponse, option=request_option
+        )
+
+    async def areply_settings(
+        self,
+        request: AnnotationReplySettingsRequest,
+        request_option: RequestOption,
+    ) -> AnnotationReplySettingsResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=AnnotationReplySettingsResponse, option=request_option
+        )
+
+    def reply_status(
+        self,
+        request: AnnotationReplyStatusRequest,
+        request_option: RequestOption,
+    ) -> AnnotationReplyStatusResponse:
+        return Transport.execute(
+            self.config, request, unmarshal_as=AnnotationReplyStatusResponse, option=request_option
+        )
+
+    async def areply_status(
+        self,
+        request: AnnotationReplyStatusRequest,
+        request_option: RequestOption,
+    ) -> AnnotationReplyStatusResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=AnnotationReplyStatusResponse, option=request_option
+        )

dify_oapi/api/chatflow/v1/resource/application.py

@@ -0,0 +1,76 @@
+from dify_oapi.core.http.transport.async_transport import ATransport
+from dify_oapi.core.http.transport.sync_transport import Transport
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.request_option import RequestOption
+
+from ..model.get_info_request import GetInfoRequest
+from ..model.get_info_response import GetInfoResponse
+from ..model.get_meta_request import GetMetaRequest
+from ..model.get_meta_response import GetMetaResponse
+from ..model.get_parameters_request import GetParametersRequest
+from ..model.get_parameters_response import GetParametersResponse
+from ..model.get_site_request import GetSiteRequest
+from ..model.get_site_response import GetSiteResponse
+
+
+class Application:
+    def __init__(self, config: Config):
+        self.config = config
+
+    def info(
+        self,
+        request: GetInfoRequest,
+        request_option: RequestOption,
+    ) -> GetInfoResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetInfoResponse, option=request_option)
+
+    async def ainfo(
+        self,
+        request: GetInfoRequest,
+        request_option: RequestOption,
+    ) -> GetInfoResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=GetInfoResponse, option=request_option)
+
+    def parameters(
+        self,
+        request: GetParametersRequest,
+        request_option: RequestOption,
+    ) -> GetParametersResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetParametersResponse, option=request_option)
+
+    async def aparameters(
+        self,
+        request: GetParametersRequest,
+        request_option: RequestOption,
+    ) -> GetParametersResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetParametersResponse, option=request_option
+        )
+
+    def meta(
+        self,
+        request: GetMetaRequest,
+        request_option: RequestOption,
+    ) -> GetMetaResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetMetaResponse, option=request_option)
+
+    async def ameta(
+        self,
+        request: GetMetaRequest,
+        request_option: RequestOption,
+    ) -> GetMetaResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=GetMetaResponse, option=request_option)
+
+    def site(
+        self,
+        request: GetSiteRequest,
+        request_option: RequestOption,
+    ) -> GetSiteResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetSiteResponse, option=request_option)
+
+    async def asite(
+        self,
+        request: GetSiteRequest,
+        request_option: RequestOption,
+    ) -> GetSiteResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=GetSiteResponse, option=request_option)

dify_oapi/api/chatflow/v1/resource/chatflow.py

@@ -0,0 +1,91 @@
+from collections.abc import AsyncGenerator, Generator
+from typing import Literal, overload
+
+from dify_oapi.core.http.transport.async_transport import ATransport
+from dify_oapi.core.http.transport.sync_transport import Transport
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.request_option import RequestOption
+
+from ..model.get_suggested_questions_request import GetSuggestedQuestionsRequest
+from ..model.get_suggested_questions_response import GetSuggestedQuestionsResponse
+from ..model.send_chat_message_request import SendChatMessageRequest
+from ..model.send_chat_message_response import SendChatMessageResponse
+from ..model.stop_chat_message_request import StopChatMessageRequest
+from ..model.stop_chat_message_response import StopChatMessageResponse
+
+
+class Chatflow:
+    def __init__(self, config: Config):
+        self.config = config
+
+    @overload
+    def send(
+        self,
+        request: SendChatMessageRequest,
+        request_option: RequestOption,
+        stream: Literal[True],
+    ) -> Generator[bytes, None, None]: ...
+
+    @overload
+    def send(
+        self,
+        request: SendChatMessageRequest,
+        request_option: RequestOption,
+        stream: Literal[False] = False,
+    ) -> SendChatMessageResponse: ...
+
+    def send(
+        self,
+        request: SendChatMessageRequest,
+        request_option: RequestOption,
+        stream: bool = False,
+    ) -> SendChatMessageResponse | Generator[bytes, None, None]:
+        if stream:
+            return Transport.execute(self.config, request, stream=True, option=request_option)
+        return Transport.execute(self.config, request, unmarshal_as=SendChatMessageResponse, option=request_option)
+
+    async def asend(
+        self,
+        request: SendChatMessageRequest,
+        request_option: RequestOption,
+        stream: bool = False,
+    ) -> SendChatMessageResponse | AsyncGenerator[bytes, None]:
+        if stream:
+            return await ATransport.aexecute(self.config, request, stream=True, option=request_option)
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=SendChatMessageResponse, option=request_option
+        )
+
+    def stop(
+        self,
+        request: StopChatMessageRequest,
+        request_option: RequestOption,
+    ) -> StopChatMessageResponse:
+        return Transport.execute(self.config, request, unmarshal_as=StopChatMessageResponse, option=request_option)
+
+    async def astop(
+        self,
+        request: StopChatMessageRequest,
+        request_option: RequestOption,
+    ) -> StopChatMessageResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=StopChatMessageResponse, option=request_option
+        )
+
+    def suggested(
+        self,
+        request: GetSuggestedQuestionsRequest,
+        request_option: RequestOption,
+    ) -> GetSuggestedQuestionsResponse:
+        return Transport.execute(
+            self.config, request, unmarshal_as=GetSuggestedQuestionsResponse, option=request_option
+        )
+
+    async def asuggested(
+        self,
+        request: GetSuggestedQuestionsRequest,
+        request_option: RequestOption,
+    ) -> GetSuggestedQuestionsResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetSuggestedQuestionsResponse, option=request_option
+        )

dify_oapi/api/chatflow/v1/resource/conversation.py

@@ -0,0 +1,104 @@
+from dify_oapi.core.http.transport.async_transport import ATransport
+from dify_oapi.core.http.transport.sync_transport import Transport
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.request_option import RequestOption
+
+from ..model.delete_conversation_request import DeleteConversationRequest
+from ..model.delete_conversation_response import DeleteConversationResponse
+from ..model.get_conversation_messages_request import GetConversationMessagesRequest
+from ..model.get_conversation_messages_response import GetConversationMessagesResponse
+from ..model.get_conversation_variables_request import GetConversationVariablesRequest
+from ..model.get_conversation_variables_response import GetConversationVariablesResponse
+from ..model.get_conversations_request import GetConversationsRequest
+from ..model.get_conversations_response import GetConversationsResponse
+from ..model.rename_conversation_request import RenameConversationRequest
+from ..model.rename_conversation_response import RenameConversationResponse
+
+
+class Conversation:
+    def __init__(self, config: Config):
+        self.config = config
+
+    def messages(
+        self,
+        request: GetConversationMessagesRequest,
+        request_option: RequestOption,
+    ) -> GetConversationMessagesResponse:
+        return Transport.execute(
+            self.config, request, unmarshal_as=GetConversationMessagesResponse, option=request_option
+        )
+
+    async def amessages(
+        self,
+        request: GetConversationMessagesRequest,
+        request_option: RequestOption,
+    ) -> GetConversationMessagesResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetConversationMessagesResponse, option=request_option
+        )
+
+    def list(
+        self,
+        request: GetConversationsRequest,
+        request_option: RequestOption,
+    ) -> GetConversationsResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetConversationsResponse, option=request_option)
+
+    async def alist(
+        self,
+        request: GetConversationsRequest,
+        request_option: RequestOption,
+    ) -> GetConversationsResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetConversationsResponse, option=request_option
+        )
+
+    def delete(
+        self,
+        request: DeleteConversationRequest,
+        request_option: RequestOption,
+    ) -> DeleteConversationResponse:
+        return Transport.execute(self.config, request, unmarshal_as=DeleteConversationResponse, option=request_option)
+
+    async def adelete(
+        self,
+        request: DeleteConversationRequest,
+        request_option: RequestOption,
+    ) -> DeleteConversationResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=DeleteConversationResponse, option=request_option
+        )
+
+    def rename(
+        self,
+        request: RenameConversationRequest,
+        request_option: RequestOption,
+    ) -> RenameConversationResponse:
+        return Transport.execute(self.config, request, unmarshal_as=RenameConversationResponse, option=request_option)
+
+    async def arename(
+        self,
+        request: RenameConversationRequest,
+        request_option: RequestOption,
+    ) -> RenameConversationResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=RenameConversationResponse, option=request_option
+        )
+
+    def variables(
+        self,
+        request: GetConversationVariablesRequest,
+        request_option: RequestOption,
+    ) -> GetConversationVariablesResponse:
+        return Transport.execute(
+            self.config, request, unmarshal_as=GetConversationVariablesResponse, option=request_option
+        )
+
+    async def avariables(
+        self,
+        request: GetConversationVariablesRequest,
+        request_option: RequestOption,
+    ) -> GetConversationVariablesResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetConversationVariablesResponse, option=request_option
+        )

dify_oapi/api/chatflow/v1/resource/feedback.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+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.get_app_feedbacks_request import GetAppFeedbacksRequest
+from ..model.get_app_feedbacks_response import GetAppFeedbacksResponse
+from ..model.message_feedback_request import MessageFeedbackRequest
+from ..model.message_feedback_response import MessageFeedbackResponse
+
+
+class Feedback:
+    """Feedback resource for chatflow API operations."""
+
+    def __init__(self, config: Config):
+        self.config = config
+
+    def message(self, request: MessageFeedbackRequest, request_option: RequestOption) -> MessageFeedbackResponse:
+        """Provide feedback for a message.
+
+        Args:
+            request: Message feedback request
+            request_option: Request options including API key
+
+        Returns:
+            Message feedback response
+        """
+        return Transport.execute(self.config, request, unmarshal_as=MessageFeedbackResponse, option=request_option)
+
+    async def amessage(self, request: MessageFeedbackRequest, request_option: RequestOption) -> MessageFeedbackResponse:
+        """Provide feedback for a message (async).
+
+        Args:
+            request: Message feedback request
+            request_option: Request options including API key
+
+        Returns:
+            Message feedback response
+        """
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=MessageFeedbackResponse, option=request_option
+        )
+
+    def list(self, request: GetAppFeedbacksRequest, request_option: RequestOption) -> GetAppFeedbacksResponse:
+        """Get application feedbacks.
+
+        Args:
+            request: Get app feedbacks request
+            request_option: Request options including API key
+
+        Returns:
+            Get app feedbacks response with feedback list
+        """
+        return Transport.execute(self.config, request, unmarshal_as=GetAppFeedbacksResponse, option=request_option)
+
+    async def alist(self, request: GetAppFeedbacksRequest, request_option: RequestOption) -> GetAppFeedbacksResponse:
+        """Get application feedbacks (async).
+
+        Args:
+            request: Get app feedbacks request
+            request_option: Request options including API key
+
+        Returns:
+            Get app feedbacks response with feedback list
+        """
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetAppFeedbacksResponse, option=request_option
+        )