dify-oapi2 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

dify_oapi/api/completion/v1/model/info/app_info.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class AppInfo(BaseModel):
+    name: str | None = None
+    description: str | None = None
+    tags: list[str] | None = None
+    mode: str | None = None
+    author_name: str | None = None
+
+    @staticmethod
+    def builder() -> AppInfoBuilder:
+        return AppInfoBuilder()
+
+
+class AppInfoBuilder:
+    def __init__(self):
+        self._app_info = AppInfo()
+
+    def build(self) -> AppInfo:
+        return self._app_info
+
+    def name(self, name: str) -> AppInfoBuilder:
+        self._app_info.name = name
+        return self
+
+    def description(self, description: str) -> AppInfoBuilder:
+        self._app_info.description = description
+        return self
+
+    def tags(self, tags: list[str]) -> AppInfoBuilder:
+        self._app_info.tags = tags
+        return self
+
+    def mode(self, mode: str) -> AppInfoBuilder:
+        self._app_info.mode = mode
+        return self
+
+    def author_name(self, author_name: str) -> AppInfoBuilder:
+        self._app_info.author_name = author_name
+        return self

dify_oapi/api/completion/v1/model/info/file_upload_config.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class FileUploadConfig(BaseModel):
+    image: dict | None = None
+
+    @staticmethod
+    def builder() -> FileUploadConfigBuilder:
+        return FileUploadConfigBuilder()
+
+
+class FileUploadConfigBuilder:
+    def __init__(self):
+        self._file_upload_config = FileUploadConfig()
+
+    def build(self) -> FileUploadConfig:
+        return self._file_upload_config
+
+    def image(self, image: dict) -> FileUploadConfigBuilder:
+        self._file_upload_config.image = image
+        return self

dify_oapi/api/completion/v1/model/info/get_info_request.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class GetInfoRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def builder() -> GetInfoRequestBuilder:
+        return GetInfoRequestBuilder()
+
+
+class GetInfoRequestBuilder:
+    def __init__(self):
+        get_info_request = GetInfoRequest()
+        get_info_request.http_method = HttpMethod.GET
+        get_info_request.uri = "/v1/info"
+        self._get_info_request = get_info_request
+
+    def build(self) -> GetInfoRequest:
+        return self._get_info_request

dify_oapi/api/completion/v1/model/info/get_info_response.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .app_info import AppInfo
+
+
+class GetInfoResponse(AppInfo, BaseResponse):
+    pass

dify_oapi/api/completion/v1/model/info/get_parameters_request.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class GetParametersRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def builder() -> GetParametersRequestBuilder:
+        return GetParametersRequestBuilder()
+
+
+class GetParametersRequestBuilder:
+    def __init__(self):
+        get_parameters_request = GetParametersRequest()
+        get_parameters_request.http_method = HttpMethod.GET
+        get_parameters_request.uri = "/v1/parameters"
+        self._get_parameters_request = get_parameters_request
+
+    def build(self) -> GetParametersRequest:
+        return self._get_parameters_request

dify_oapi/api/completion/v1/model/info/get_parameters_response.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .parameters_info import ParametersInfo
+
+
+class GetParametersResponse(ParametersInfo, BaseResponse):
+    pass

dify_oapi/api/completion/v1/model/info/get_site_request.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class GetSiteRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def builder() -> GetSiteRequestBuilder:
+        return GetSiteRequestBuilder()
+
+
+class GetSiteRequestBuilder:
+    def __init__(self):
+        get_site_request = GetSiteRequest()
+        get_site_request.http_method = HttpMethod.GET
+        get_site_request.uri = "/v1/site"
+        self._get_site_request = get_site_request
+
+    def build(self) -> GetSiteRequest:
+        return self._get_site_request

dify_oapi/api/completion/v1/model/info/get_site_response.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .site_info import SiteInfo
+
+
+class GetSiteResponse(SiteInfo, BaseResponse):
+    pass

dify_oapi/api/completion/v1/model/info/parameters_info.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .file_upload_config import FileUploadConfig
+from .system_parameters import SystemParameters
+from .user_input_form import UserInputForm
+
+
+class ParametersInfo(BaseModel):
+    opening_statement: str | None = None
+    suggested_questions: list[str] | None = None
+    suggested_questions_after_answer: dict | None = None
+    speech_to_text: dict | None = None
+    retriever_resource: dict | None = None
+    annotation_reply: dict | None = None
+    user_input_form: list[UserInputForm] | None = None
+    file_upload: FileUploadConfig | None = None
+    system_parameters: SystemParameters | None = None
+
+    @staticmethod
+    def builder() -> ParametersInfoBuilder:
+        return ParametersInfoBuilder()
+
+
+class ParametersInfoBuilder:
+    def __init__(self):
+        self._parameters_info = ParametersInfo()
+
+    def build(self) -> ParametersInfo:
+        return self._parameters_info
+
+    def opening_statement(self, opening_statement: str) -> ParametersInfoBuilder:
+        self._parameters_info.opening_statement = opening_statement
+        return self
+
+    def suggested_questions(self, suggested_questions: list[str]) -> ParametersInfoBuilder:
+        self._parameters_info.suggested_questions = suggested_questions
+        return self
+
+    def suggested_questions_after_answer(self, suggested_questions_after_answer: dict) -> ParametersInfoBuilder:
+        self._parameters_info.suggested_questions_after_answer = suggested_questions_after_answer
+        return self
+
+    def speech_to_text(self, speech_to_text: dict) -> ParametersInfoBuilder:
+        self._parameters_info.speech_to_text = speech_to_text
+        return self
+
+    def retriever_resource(self, retriever_resource: dict) -> ParametersInfoBuilder:
+        self._parameters_info.retriever_resource = retriever_resource
+        return self
+
+    def annotation_reply(self, annotation_reply: dict) -> ParametersInfoBuilder:
+        self._parameters_info.annotation_reply = annotation_reply
+        return self
+
+    def user_input_form(self, user_input_form: list[UserInputForm]) -> ParametersInfoBuilder:
+        self._parameters_info.user_input_form = user_input_form
+        return self
+
+    def file_upload(self, file_upload: FileUploadConfig) -> ParametersInfoBuilder:
+        self._parameters_info.file_upload = file_upload
+        return self
+
+    def system_parameters(self, system_parameters: SystemParameters) -> ParametersInfoBuilder:
+        self._parameters_info.system_parameters = system_parameters
+        return self

dify_oapi/api/completion/v1/model/info/site_info.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from ..completion.completion_types import IconType
+
+
+class SiteInfo(BaseModel):
+    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() -> SiteInfoBuilder:
+        return SiteInfoBuilder()
+
+
+class SiteInfoBuilder:
+    def __init__(self):
+        self._site_info = SiteInfo()
+
+    def build(self) -> SiteInfo:
+        return self._site_info
+
+    def title(self, title: str) -> SiteInfoBuilder:
+        self._site_info.title = title
+        return self
+
+    def chat_color_theme(self, chat_color_theme: str) -> SiteInfoBuilder:
+        self._site_info.chat_color_theme = chat_color_theme
+        return self
+
+    def chat_color_theme_inverted(self, chat_color_theme_inverted: bool) -> SiteInfoBuilder:
+        self._site_info.chat_color_theme_inverted = chat_color_theme_inverted
+        return self
+
+    def icon_type(self, icon_type: IconType) -> SiteInfoBuilder:
+        self._site_info.icon_type = icon_type
+        return self
+
+    def icon(self, icon: str) -> SiteInfoBuilder:
+        self._site_info.icon = icon
+        return self
+
+    def icon_background(self, icon_background: str) -> SiteInfoBuilder:
+        self._site_info.icon_background = icon_background
+        return self
+
+    def icon_url(self, icon_url: str) -> SiteInfoBuilder:
+        self._site_info.icon_url = icon_url
+        return self
+
+    def description(self, description: str) -> SiteInfoBuilder:
+        self._site_info.description = description
+        return self
+
+    def copyright(self, copyright: str) -> SiteInfoBuilder:
+        self._site_info.copyright = copyright
+        return self
+
+    def privacy_policy(self, privacy_policy: str) -> SiteInfoBuilder:
+        self._site_info.privacy_policy = privacy_policy
+        return self
+
+    def custom_disclaimer(self, custom_disclaimer: str) -> SiteInfoBuilder:
+        self._site_info.custom_disclaimer = custom_disclaimer
+        return self
+
+    def default_language(self, default_language: str) -> SiteInfoBuilder:
+        self._site_info.default_language = default_language
+        return self
+
+    def show_workflow_steps(self, show_workflow_steps: bool) -> SiteInfoBuilder:
+        self._site_info.show_workflow_steps = show_workflow_steps
+        return self
+
+    def use_icon_as_answer_icon(self, use_icon_as_answer_icon: bool) -> SiteInfoBuilder:
+        self._site_info.use_icon_as_answer_icon = use_icon_as_answer_icon
+        return self

dify_oapi/api/completion/v1/model/info/system_parameters.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class SystemParameters(BaseModel):
+    file_size_limit: int | None = None
+    image_file_size_limit: int | None = None
+    audio_file_size_limit: int | None = None
+    video_file_size_limit: int | None = None
+
+    @staticmethod
+    def builder() -> SystemParametersBuilder:
+        return SystemParametersBuilder()
+
+
+class SystemParametersBuilder:
+    def __init__(self):
+        self._system_parameters = SystemParameters()
+
+    def build(self) -> SystemParameters:
+        return self._system_parameters
+
+    def file_size_limit(self, file_size_limit: int) -> SystemParametersBuilder:
+        self._system_parameters.file_size_limit = file_size_limit
+        return self
+
+    def image_file_size_limit(self, image_file_size_limit: int) -> SystemParametersBuilder:
+        self._system_parameters.image_file_size_limit = image_file_size_limit
+        return self
+
+    def audio_file_size_limit(self, audio_file_size_limit: int) -> SystemParametersBuilder:
+        self._system_parameters.audio_file_size_limit = audio_file_size_limit
+        return self
+
+    def video_file_size_limit(self, video_file_size_limit: int) -> SystemParametersBuilder:
+        self._system_parameters.video_file_size_limit = video_file_size_limit
+        return self

dify_oapi/api/completion/v1/model/info/user_input_form.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class UserInputForm(BaseModel):
+    label: str | None = None
+    variable: str | None = None
+    required: bool | None = None
+    default: str | None = None
+    options: list[str] | None = None
+
+    @staticmethod
+    def builder() -> UserInputFormBuilder:
+        return UserInputFormBuilder()
+
+
+class UserInputFormBuilder:
+    def __init__(self):
+        self._user_input_form = UserInputForm()
+
+    def build(self) -> UserInputForm:
+        return self._user_input_form
+
+    def label(self, label: str) -> UserInputFormBuilder:
+        self._user_input_form.label = label
+        return self
+
+    def variable(self, variable: str) -> UserInputFormBuilder:
+        self._user_input_form.variable = variable
+        return self
+
+    def required(self, required: bool) -> UserInputFormBuilder:
+        self._user_input_form.required = required
+        return self
+
+    def default(self, default: str) -> UserInputFormBuilder:
+        self._user_input_form.default = default
+        return self
+
+    def options(self, options: list[str]) -> UserInputFormBuilder:
+        self._user_input_form.options = options
+        return self

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

@@ -1 +1,6 @@
+from .annotation import *  # noqa 403
+from .audio import *  # noqa 403
 from .completion import *  # noqa 403
+from .feedback import *  # noqa 403
+from .file import *  # noqa 403
+from .info import *  # noqa 403

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

@@ -0,0 +1,99 @@
+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.annotation.annotation_reply_settings_request import AnnotationReplySettingsRequest
+from ..model.annotation.annotation_reply_settings_response import AnnotationReplySettingsResponse
+from ..model.annotation.create_annotation_request import CreateAnnotationRequest
+from ..model.annotation.create_annotation_response import CreateAnnotationResponse
+from ..model.annotation.delete_annotation_request import DeleteAnnotationRequest
+from ..model.annotation.delete_annotation_response import DeleteAnnotationResponse
+from ..model.annotation.list_annotations_request import ListAnnotationsRequest
+from ..model.annotation.list_annotations_response import ListAnnotationsResponse
+from ..model.annotation.query_annotation_reply_status_request import QueryAnnotationReplyStatusRequest
+from ..model.annotation.query_annotation_reply_status_response import QueryAnnotationReplyStatusResponse
+from ..model.annotation.update_annotation_request import UpdateAnnotationRequest
+from ..model.annotation.update_annotation_response import UpdateAnnotationResponse
+
+
+class Annotation:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def list_annotations(
+        self, request: ListAnnotationsRequest, request_option: RequestOption
+    ) -> ListAnnotationsResponse:
+        return Transport.execute(self.config, request, unmarshal_as=ListAnnotationsResponse, option=request_option)
+
+    async def alist_annotations(
+        self, request: ListAnnotationsRequest, request_option: RequestOption
+    ) -> ListAnnotationsResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=ListAnnotationsResponse, option=request_option
+        )
+
+    def create_annotation(
+        self, request: CreateAnnotationRequest, request_option: RequestOption
+    ) -> CreateAnnotationResponse:
+        return Transport.execute(self.config, request, unmarshal_as=CreateAnnotationResponse, option=request_option)
+
+    async def acreate_annotation(
+        self, request: CreateAnnotationRequest, request_option: RequestOption
+    ) -> CreateAnnotationResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=CreateAnnotationResponse, option=request_option
+        )
+
+    def update_annotation(
+        self, request: UpdateAnnotationRequest, request_option: RequestOption
+    ) -> UpdateAnnotationResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateAnnotationResponse, option=request_option)
+
+    async def aupdate_annotation(
+        self, request: UpdateAnnotationRequest, request_option: RequestOption
+    ) -> UpdateAnnotationResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=UpdateAnnotationResponse, option=request_option
+        )
+
+    def delete_annotation(
+        self, request: DeleteAnnotationRequest, request_option: RequestOption
+    ) -> DeleteAnnotationResponse:
+        return Transport.execute(self.config, request, unmarshal_as=DeleteAnnotationResponse, option=request_option)
+
+    async def adelete_annotation(
+        self, request: DeleteAnnotationRequest, request_option: RequestOption
+    ) -> DeleteAnnotationResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=DeleteAnnotationResponse, option=request_option
+        )
+
+    def annotation_reply_settings(
+        self, request: AnnotationReplySettingsRequest, request_option: RequestOption
+    ) -> AnnotationReplySettingsResponse:
+        return Transport.execute(
+            self.config, request, unmarshal_as=AnnotationReplySettingsResponse, option=request_option
+        )
+
+    async def aannotation_reply_settings(
+        self, request: AnnotationReplySettingsRequest, request_option: RequestOption
+    ) -> AnnotationReplySettingsResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=AnnotationReplySettingsResponse, option=request_option
+        )
+
+    def query_annotation_reply_status(
+        self, request: QueryAnnotationReplyStatusRequest, request_option: RequestOption
+    ) -> QueryAnnotationReplyStatusResponse:
+        return Transport.execute(
+            self.config, request, unmarshal_as=QueryAnnotationReplyStatusResponse, option=request_option
+        )
+
+    async def aquery_annotation_reply_status(
+        self, request: QueryAnnotationReplyStatusRequest, request_option: RequestOption
+    ) -> QueryAnnotationReplyStatusResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=QueryAnnotationReplyStatusResponse, option=request_option
+        )

dify_oapi/api/completion/v1/resource/audio.py

@@ -0,0 +1,19 @@
+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.audio.text_to_audio_request import TextToAudioRequest
+from ..model.audio.text_to_audio_response import TextToAudioResponse
+
+
+class Audio:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def text_to_audio(self, request: TextToAudioRequest, request_option: RequestOption) -> TextToAudioResponse:
+        return Transport.execute(self.config, request, unmarshal_as=TextToAudioResponse, option=request_option)
+
+    async def atext_to_audio(self, request: TextToAudioRequest, request_option: RequestOption) -> TextToAudioResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=TextToAudioResponse, option=request_option)

dify_oapi/api/completion/v1/resource/completion.py

@@ -5,10 +5,10 @@ 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.completion_request import CompletionRequest
-from ..model.completion_response import CompletionResponse
-from ..model.stop_completion_request import StopCompletionRequest
-from ..model.stop_completion_response import StopCompletionResponse
+from ..model.completion.send_message_request import SendMessageRequest
+from ..model.completion.send_message_response import SendMessageResponse
+from ..model.completion.stop_response_request import StopResponseRequest
+from ..model.completion.stop_response_response import StopResponseResponse
 
 
 class Completion:
@@ -16,69 +16,59 @@ class Completion:
         self.config: Config = config
 
     @overload
-    def completion(
+    def send_message(
         self,
-        request: CompletionRequest,
-        option: RequestOption | None,
+        request: SendMessageRequest,
+        request_option: RequestOption,
         stream: Literal[True],
     ) -> Generator[bytes, None, None]: ...
 
     @overload
-    def completion(
+    def send_message(
         self,
-        request: CompletionRequest,
-        option: RequestOption | None,
-        stream: Literal[False],
-    ) -> CompletionResponse: ...
+        request: SendMessageRequest,
+        request_option: RequestOption,
+        stream: Literal[False] = False,
+    ) -> SendMessageResponse: ...
 
-    @overload
-    def completion(self, request: CompletionRequest, option: RequestOption | None) -> CompletionResponse: ...
-
-    def completion(
+    def send_message(
         self,
-        request: CompletionRequest,
-        option: RequestOption | None = None,
+        request: SendMessageRequest,
+        request_option: RequestOption,
         stream: bool = False,
-    ):
+    ) -> SendMessageResponse | 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=CompletionResponse, option=option)
+            return Transport.execute(self.config, request, stream=True, option=request_option)
+        return Transport.execute(self.config, request, unmarshal_as=SendMessageResponse, option=request_option)
 
     @overload
-    async def acompletion(
+    async def asend_message(
         self,
-        request: CompletionRequest,
-        option: RequestOption | None,
+        request: SendMessageRequest,
+        request_option: RequestOption,
         stream: Literal[True],
     ) -> AsyncGenerator[bytes, None]: ...
 
     @overload
-    async def acompletion(
+    async def asend_message(
         self,
-        request: CompletionRequest,
-        option: RequestOption | None,
-        stream: Literal[False],
-    ) -> CompletionResponse: ...
-
-    @overload
-    async def acompletion(self, request: CompletionRequest, option: RequestOption | None) -> CompletionResponse: ...
+        request: SendMessageRequest,
+        request_option: RequestOption,
+        stream: Literal[False] = False,
+    ) -> SendMessageResponse: ...
 
-    async def acompletion(
+    async def asend_message(
         self,
-        request: CompletionRequest,
-        option: RequestOption | None = None,
+        request: SendMessageRequest,
+        request_option: RequestOption,
         stream: bool = False,
-    ):
+    ) -> SendMessageResponse | 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=CompletionResponse, option=option)
+            return await ATransport.aexecute(self.config, request, stream=True, option=request_option)
+        return await ATransport.aexecute(self.config, request, unmarshal_as=SendMessageResponse, option=request_option)
 
-    def stop(self, request: StopCompletionRequest, option: RequestOption | None = None) -> StopCompletionResponse:
-        return Transport.execute(self.config, request, unmarshal_as=StopCompletionResponse, option=option)
+    def stop_response(self, request: StopResponseRequest, request_option: RequestOption) -> StopResponseResponse:
+        return Transport.execute(self.config, request, unmarshal_as=StopResponseResponse, option=request_option)
 
-    async def astop(
-        self, request: StopCompletionRequest, option: RequestOption | None = None
-    ) -> StopCompletionResponse:
-        return await ATransport.aexecute(self.config, request, unmarshal_as=StopCompletionResponse, option=option)
+    async def astop_response(self, request: StopResponseRequest, request_option: RequestOption) -> StopResponseResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=StopResponseResponse, option=request_option)