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

dify_oapi/api/completion/v1/model/annotation/annotation_info.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class AnnotationInfo(BaseModel):
+    id: str | None = None
+    question: str | None = None
+    answer: str | None = None
+    hit_count: int | None = None
+    created_at: int | None = None
+
+    @staticmethod
+    def builder() -> AnnotationInfoBuilder:
+        return AnnotationInfoBuilder()
+
+
+class AnnotationInfoBuilder:
+    def __init__(self):
+        self._annotation_info = AnnotationInfo()
+
+    def build(self) -> AnnotationInfo:
+        return self._annotation_info
+
+    def id(self, id: str) -> AnnotationInfoBuilder:
+        self._annotation_info.id = id
+        return self
+
+    def question(self, question: str) -> AnnotationInfoBuilder:
+        self._annotation_info.question = question
+        return self
+
+    def answer(self, answer: str) -> AnnotationInfoBuilder:
+        self._annotation_info.answer = answer
+        return self
+
+    def hit_count(self, hit_count: int) -> AnnotationInfoBuilder:
+        self._annotation_info.hit_count = hit_count
+        return self
+
+    def created_at(self, created_at: int) -> AnnotationInfoBuilder:
+        self._annotation_info.created_at = created_at
+        return self

dify_oapi/api/completion/v1/model/annotation/annotation_reply_settings_request.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from ..completion.completion_types import AnnotationAction
+from .annotation_reply_settings_request_body import AnnotationReplySettingsRequestBody
+
+
+class AnnotationReplySettingsRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.action: AnnotationAction | None = None
+        self.request_body: AnnotationReplySettingsRequestBody | None = None
+
+    @staticmethod
+    def builder() -> AnnotationReplySettingsRequestBuilder:
+        return AnnotationReplySettingsRequestBuilder()
+
+
+class AnnotationReplySettingsRequestBuilder:
+    def __init__(self):
+        annotation_reply_settings_request = AnnotationReplySettingsRequest()
+        annotation_reply_settings_request.http_method = HttpMethod.POST
+        annotation_reply_settings_request.uri = "/v1/apps/annotation-reply/:action"
+        self._annotation_reply_settings_request = annotation_reply_settings_request
+
+    def build(self) -> AnnotationReplySettingsRequest:
+        return self._annotation_reply_settings_request
+
+    def action(self, action: AnnotationAction) -> AnnotationReplySettingsRequestBuilder:
+        self._annotation_reply_settings_request.action = action
+        self._annotation_reply_settings_request.paths["action"] = action
+        return self
+
+    def request_body(self, request_body: AnnotationReplySettingsRequestBody) -> AnnotationReplySettingsRequestBuilder:
+        self._annotation_reply_settings_request.request_body = request_body
+        self._annotation_reply_settings_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

dify_oapi/api/completion/v1/model/annotation/annotation_reply_settings_request_body.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class AnnotationReplySettingsRequestBody(BaseModel):
+    embedding_provider_name: str | None = None
+    embedding_model_name: str | None = None
+    score_threshold: float | None = None
+
+    @staticmethod
+    def builder() -> AnnotationReplySettingsRequestBodyBuilder:
+        return AnnotationReplySettingsRequestBodyBuilder()
+
+
+class AnnotationReplySettingsRequestBodyBuilder:
+    def __init__(self):
+        self._annotation_reply_settings_request_body = AnnotationReplySettingsRequestBody()
+
+    def build(self) -> AnnotationReplySettingsRequestBody:
+        return self._annotation_reply_settings_request_body
+
+    def embedding_provider_name(self, embedding_provider_name: str) -> AnnotationReplySettingsRequestBodyBuilder:
+        self._annotation_reply_settings_request_body.embedding_provider_name = embedding_provider_name
+        return self
+
+    def embedding_model_name(self, embedding_model_name: str) -> AnnotationReplySettingsRequestBodyBuilder:
+        self._annotation_reply_settings_request_body.embedding_model_name = embedding_model_name
+        return self
+
+    def score_threshold(self, score_threshold: float) -> AnnotationReplySettingsRequestBodyBuilder:
+        self._annotation_reply_settings_request_body.score_threshold = score_threshold
+        return self

dify_oapi/api/completion/v1/model/annotation/annotation_reply_settings_response.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .job_status_info import JobStatusInfo
+
+
+class AnnotationReplySettingsResponse(JobStatusInfo, BaseResponse):
+    pass

dify_oapi/api/completion/v1/model/annotation/create_annotation_request.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .create_annotation_request_body import CreateAnnotationRequestBody
+
+
+class CreateAnnotationRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.request_body: CreateAnnotationRequestBody | None = None
+
+    @staticmethod
+    def builder() -> CreateAnnotationRequestBuilder:
+        return CreateAnnotationRequestBuilder()
+
+
+class CreateAnnotationRequestBuilder:
+    def __init__(self):
+        create_annotation_request = CreateAnnotationRequest()
+        create_annotation_request.http_method = HttpMethod.POST
+        create_annotation_request.uri = "/v1/apps/annotations"
+        self._create_annotation_request = create_annotation_request
+
+    def build(self) -> CreateAnnotationRequest:
+        return self._create_annotation_request
+
+    def request_body(self, request_body: CreateAnnotationRequestBody) -> CreateAnnotationRequestBuilder:
+        self._create_annotation_request.request_body = request_body
+        self._create_annotation_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

dify_oapi/api/completion/v1/model/annotation/create_annotation_request_body.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class CreateAnnotationRequestBody(BaseModel):
+    question: str | None = None
+    answer: str | None = None
+
+    @staticmethod
+    def builder() -> CreateAnnotationRequestBodyBuilder:
+        return CreateAnnotationRequestBodyBuilder()
+
+
+class CreateAnnotationRequestBodyBuilder:
+    def __init__(self):
+        self._create_annotation_request_body = CreateAnnotationRequestBody()
+
+    def build(self) -> CreateAnnotationRequestBody:
+        return self._create_annotation_request_body
+
+    def question(self, question: str) -> CreateAnnotationRequestBodyBuilder:
+        self._create_annotation_request_body.question = question
+        return self
+
+    def answer(self, answer: str) -> CreateAnnotationRequestBodyBuilder:
+        self._create_annotation_request_body.answer = answer
+        return self

dify_oapi/api/completion/v1/model/annotation/create_annotation_response.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .annotation_info import AnnotationInfo
+
+
+class CreateAnnotationResponse(AnnotationInfo, BaseResponse):
+    pass

dify_oapi/api/completion/v1/model/annotation/delete_annotation_request.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class DeleteAnnotationRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.annotation_id: str | None = None
+
+    @staticmethod
+    def builder() -> DeleteAnnotationRequestBuilder:
+        return DeleteAnnotationRequestBuilder()
+
+
+class DeleteAnnotationRequestBuilder:
+    def __init__(self):
+        delete_annotation_request = DeleteAnnotationRequest()
+        delete_annotation_request.http_method = HttpMethod.DELETE
+        delete_annotation_request.uri = "/v1/apps/annotations/:annotation_id"
+        self._delete_annotation_request = delete_annotation_request
+
+    def build(self) -> DeleteAnnotationRequest:
+        return self._delete_annotation_request
+
+    def annotation_id(self, annotation_id: str) -> DeleteAnnotationRequestBuilder:
+        self._delete_annotation_request.annotation_id = annotation_id
+        self._delete_annotation_request.paths["annotation_id"] = annotation_id
+        return self

dify_oapi/api/completion/v1/model/annotation/delete_annotation_response.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class DeleteAnnotationResponse(BaseResponse):
+    pass

dify_oapi/api/completion/v1/model/annotation/job_status_info.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from ..completion.completion_types import JobStatus
+
+
+class JobStatusInfo(BaseModel):
+    job_id: str | None = None
+    job_status: JobStatus | None = None
+    error_msg: str | None = None
+
+    @staticmethod
+    def builder() -> JobStatusInfoBuilder:
+        return JobStatusInfoBuilder()
+
+
+class JobStatusInfoBuilder:
+    def __init__(self):
+        self._job_status_info = JobStatusInfo()
+
+    def build(self) -> JobStatusInfo:
+        return self._job_status_info
+
+    def job_id(self, job_id: str) -> JobStatusInfoBuilder:
+        self._job_status_info.job_id = job_id
+        return self
+
+    def job_status(self, job_status: JobStatus) -> JobStatusInfoBuilder:
+        self._job_status_info.job_status = job_status
+        return self
+
+    def error_msg(self, error_msg: str) -> JobStatusInfoBuilder:
+        self._job_status_info.error_msg = error_msg
+        return self

dify_oapi/api/completion/v1/model/annotation/list_annotations_request.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class ListAnnotationsRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def builder() -> ListAnnotationsRequestBuilder:
+        return ListAnnotationsRequestBuilder()
+
+
+class ListAnnotationsRequestBuilder:
+    def __init__(self):
+        list_annotations_request = ListAnnotationsRequest()
+        list_annotations_request.http_method = HttpMethod.GET
+        list_annotations_request.uri = "/v1/apps/annotations"
+        self._list_annotations_request = list_annotations_request
+
+    def build(self) -> ListAnnotationsRequest:
+        return self._list_annotations_request
+
+    def page(self, page: str) -> ListAnnotationsRequestBuilder:
+        self._list_annotations_request.add_query("page", page)
+        return self
+
+    def limit(self, limit: str) -> ListAnnotationsRequestBuilder:
+        self._list_annotations_request.add_query("limit", limit)
+        return self

dify_oapi/api/completion/v1/model/annotation/list_annotations_response.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .annotation_info import AnnotationInfo
+
+
+class ListAnnotationsResponse(BaseResponse):
+    data: list[AnnotationInfo] | None = None
+    has_more: bool | None = None
+    limit: int | None = None
+    total: int | None = None
+    page: int | None = None

dify_oapi/api/completion/v1/model/annotation/query_annotation_reply_status_request.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from ..completion.completion_types import AnnotationAction
+
+
+class QueryAnnotationReplyStatusRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.action: AnnotationAction | None = None
+        self.job_id: str | None = None
+
+    @staticmethod
+    def builder() -> QueryAnnotationReplyStatusRequestBuilder:
+        return QueryAnnotationReplyStatusRequestBuilder()
+
+
+class QueryAnnotationReplyStatusRequestBuilder:
+    def __init__(self):
+        query_annotation_reply_status_request = QueryAnnotationReplyStatusRequest()
+        query_annotation_reply_status_request.http_method = HttpMethod.GET
+        query_annotation_reply_status_request.uri = "/v1/apps/annotation-reply/:action/status/:job_id"
+        self._query_annotation_reply_status_request = query_annotation_reply_status_request
+
+    def build(self) -> QueryAnnotationReplyStatusRequest:
+        return self._query_annotation_reply_status_request
+
+    def action(self, action: AnnotationAction) -> QueryAnnotationReplyStatusRequestBuilder:
+        self._query_annotation_reply_status_request.action = action
+        self._query_annotation_reply_status_request.paths["action"] = action
+        return self
+
+    def job_id(self, job_id: str) -> QueryAnnotationReplyStatusRequestBuilder:
+        self._query_annotation_reply_status_request.job_id = job_id
+        self._query_annotation_reply_status_request.paths["job_id"] = job_id
+        return self

dify_oapi/api/completion/v1/model/annotation/query_annotation_reply_status_response.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .job_status_info import JobStatusInfo
+
+
+class QueryAnnotationReplyStatusResponse(JobStatusInfo, BaseResponse):
+    pass

dify_oapi/api/completion/v1/model/annotation/update_annotation_request.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+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.annotation_id: str | None = None
+        self.request_body: UpdateAnnotationRequestBody | 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/completion/v1/model/annotation/update_annotation_request_body.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class UpdateAnnotationRequestBody(BaseModel):
+    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/completion/v1/model/annotation/update_annotation_response.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .annotation_info import AnnotationInfo
+
+
+class UpdateAnnotationResponse(AnnotationInfo, BaseResponse):
+    pass

dify_oapi/api/completion/v1/model/audio/audio_info.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class AudioInfo(BaseModel):
+    content_type: str | None = None
+    data: bytes | None = None
+
+    @staticmethod
+    def builder() -> AudioInfoBuilder:
+        return AudioInfoBuilder()
+
+
+class AudioInfoBuilder:
+    def __init__(self):
+        self._audio_info = AudioInfo()
+
+    def build(self) -> AudioInfo:
+        return self._audio_info
+
+    def content_type(self, content_type: str) -> AudioInfoBuilder:
+        self._audio_info.content_type = content_type
+        return self
+
+    def data(self, data: bytes) -> AudioInfoBuilder:
+        self._audio_info.data = data
+        return self

dify_oapi/api/completion/v1/model/audio/text_to_audio_request.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .text_to_audio_request_body import TextToAudioRequestBody
+
+
+class TextToAudioRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.request_body: TextToAudioRequestBody | None = None
+
+    @staticmethod
+    def builder() -> TextToAudioRequestBuilder:
+        return TextToAudioRequestBuilder()
+
+
+class TextToAudioRequestBuilder:
+    def __init__(self):
+        text_to_audio_request = TextToAudioRequest()
+        text_to_audio_request.http_method = HttpMethod.POST
+        text_to_audio_request.uri = "/v1/text-to-audio"
+        self._text_to_audio_request = text_to_audio_request
+
+    def build(self) -> TextToAudioRequest:
+        return self._text_to_audio_request
+
+    def request_body(self, request_body: TextToAudioRequestBody) -> TextToAudioRequestBuilder:
+        self._text_to_audio_request.request_body = request_body
+        self._text_to_audio_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

dify_oapi/api/completion/v1/model/audio/text_to_audio_request_body.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class TextToAudioRequestBody(BaseModel):
+    message_id: str | None = None
+    text: str | None = None
+    user: str | None = None
+
+    @staticmethod
+    def builder() -> TextToAudioRequestBodyBuilder:
+        return TextToAudioRequestBodyBuilder()
+
+
+class TextToAudioRequestBodyBuilder:
+    def __init__(self):
+        self._text_to_audio_request_body = TextToAudioRequestBody()
+
+    def build(self) -> TextToAudioRequestBody:
+        return self._text_to_audio_request_body
+
+    def message_id(self, message_id: str) -> TextToAudioRequestBodyBuilder:
+        self._text_to_audio_request_body.message_id = message_id
+        return self
+
+    def text(self, text: str) -> TextToAudioRequestBodyBuilder:
+        self._text_to_audio_request_body.text = text
+        return self
+
+    def user(self, user: str) -> TextToAudioRequestBodyBuilder:
+        self._text_to_audio_request_body.user = user
+        return self

dify_oapi/api/completion/v1/model/audio/text_to_audio_response.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .audio_info import AudioInfo
+
+
+class TextToAudioResponse(AudioInfo, BaseResponse):
+    pass

dify_oapi/api/completion/v1/model/completion/completion_inputs.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class CompletionInputs(BaseModel):
+    """
+    Inputs for completion application containing variables defined in the App.
+    Text generation applications require at least the query field.
+    """
+
+    query: str | None = None  # User input text content (required for completion apps)
+
+    @staticmethod
+    def builder() -> CompletionInputsBuilder:
+        return CompletionInputsBuilder()
+
+
+class CompletionInputsBuilder:
+    def __init__(self):
+        self._completion_inputs = CompletionInputs()
+
+    def build(self) -> CompletionInputs:
+        return self._completion_inputs
+
+    def query(self, query: str) -> CompletionInputsBuilder:
+        self._completion_inputs.query = query
+        return self

dify_oapi/api/completion/v1/model/completion/completion_message_info.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .completion_types import AppMode
+from .metadata import Metadata
+
+
+class CompletionMessageInfo(BaseModel):
+    message_id: str | None = None
+    mode: AppMode | None = None
+    answer: str | None = None
+    metadata: Metadata | None = None
+    created_at: int | None = None
+
+    @staticmethod
+    def builder() -> CompletionMessageInfoBuilder:
+        return CompletionMessageInfoBuilder()
+
+
+class CompletionMessageInfoBuilder:
+    def __init__(self):
+        self._completion_message_info = CompletionMessageInfo()
+
+    def build(self) -> CompletionMessageInfo:
+        return self._completion_message_info
+
+    def message_id(self, message_id: str) -> CompletionMessageInfoBuilder:
+        self._completion_message_info.message_id = message_id
+        return self
+
+    def mode(self, mode: AppMode) -> CompletionMessageInfoBuilder:
+        self._completion_message_info.mode = mode
+        return self
+
+    def answer(self, answer: str) -> CompletionMessageInfoBuilder:
+        self._completion_message_info.answer = answer
+        return self
+
+    def metadata(self, metadata: Metadata) -> CompletionMessageInfoBuilder:
+        self._completion_message_info.metadata = metadata
+        return self
+
+    def created_at(self, created_at: int) -> CompletionMessageInfoBuilder:
+        self._completion_message_info.created_at = created_at
+        return self

dify_oapi/api/completion/v1/model/completion/completion_types.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import Literal
+
+# Response mode types
+ResponseMode = Literal["streaming", "blocking"]
+
+# File types
+FileType = Literal["image"]
+
+# Transfer method types
+TransferMethod = Literal["remote_url", "local_file"]
+
+# Feedback rating types
+FeedbackRating = Literal["like", "dislike", "null"]
+
+# Annotation action types
+AnnotationAction = Literal["enable", "disable"]
+
+# Icon types
+IconType = Literal["emoji", "image"]
+
+# App mode types
+AppMode = Literal["completion"]
+
+# Job status types
+JobStatus = Literal["waiting", "running", "completed", "failed"]