dify-oapi2 0.1.0__py3-none-any.whl

dify_oapi/api/dify/v1/model/get_meta_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 GetMetaRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.user: str | None = None
+
+    @staticmethod
+    def builder() -> GetMetaRequestBuilder:
+        return GetMetaRequestBuilder()
+
+
+class GetMetaRequestBuilder:
+    def __init__(self):
+        get_meta_request = GetMetaRequest()
+        get_meta_request.http_method = HttpMethod.GET
+        get_meta_request.uri = "/v1/meta"
+        self._get_meta_request = get_meta_request
+
+    def build(self) -> GetMetaRequest:
+        return self._get_meta_request
+
+    def user(self, user: str) -> GetMetaRequestBuilder:
+        self._get_meta_request.user = user
+        self._get_meta_request.add_query("user", user)
+        return self

dify_oapi/api/dify/v1/model/get_meta_response.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class GetMetaResponse(BaseResponse):
+    tool_icons: GetMetaResponseToolIcons | None = None
+
+
+class GetMetaResponseToolIcons(BaseModel):
+    dalle2: str | None = None
+    api_tool: GetMetaResponseApiTool | None = None
+
+
+class GetMetaResponseApiTool(BaseModel):
+    background: str | None = None
+    content: str | None = None

dify_oapi/api/dify/v1/model/get_parameter_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 GetParameterRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.user: str | None = None
+
+    @staticmethod
+    def builder() -> GetParameterRequestBuilder:
+        return GetParameterRequestBuilder()
+
+
+class GetParameterRequestBuilder:
+    def __init__(self) -> None:
+        get_parameter_request = GetParameterRequest()
+        get_parameter_request.http_method = HttpMethod.GET
+        get_parameter_request.uri = "/v1/parameters"
+        self._get_parameter_request: GetParameterRequest = get_parameter_request
+
+    def build(self) -> GetParameterRequest:
+        return self._get_parameter_request
+
+    def user(self, user: str) -> GetParameterRequestBuilder:
+        self._get_parameter_request.user = user
+        self._get_parameter_request.add_query("user", user)
+        return self

dify_oapi/api/dify/v1/model/get_parameter_response.py

@@ -0,0 +1,13 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class GetParameterResponse(BaseResponse):
+    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[dict] | None = None
+    file_upload: dict | None = None
+    system_parameters: dict | None = None

dify_oapi/api/dify/v1/model/message_feedback_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 ..model.message_feedback_request_body import MessageFeedbackRequestBody
+
+
+class MessageFeedbackRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.message_id: str | None = None
+        self.request_body: MessageFeedbackRequestBody | None = None
+
+    @staticmethod
+    def builder() -> MessageFeedbackRequestBuilder:
+        return MessageFeedbackRequestBuilder()
+
+
+class MessageFeedbackRequestBuilder:
+    def __init__(self):
+        message_feedback_request = MessageFeedbackRequest()
+        message_feedback_request.http_method = HttpMethod.POST
+        message_feedback_request.uri = "/v1/messages/:message_id/feedbacks"
+        self._message_feedback_request = message_feedback_request
+
+    def build(self) -> MessageFeedbackRequest:
+        return self._message_feedback_request
+
+    def message_id(self, message_id: str) -> MessageFeedbackRequestBuilder:
+        self._message_feedback_request.message_id = message_id
+        self._message_feedback_request.paths["message_id"] = message_id
+        return self
+
+    def request_body(self, request_body: MessageFeedbackRequestBody) -> MessageFeedbackRequestBuilder:
+        self._message_feedback_request.request_body = request_body
+        self._message_feedback_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

dify_oapi/api/dify/v1/model/message_feedback_request_body.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class MessageFeedbackRequestBody(BaseModel):
+    rating: str | None = None
+    user: str | None = None
+
+    @staticmethod
+    def builder() -> MessageFeedbackRequestBodyBuilder:
+        return MessageFeedbackRequestBodyBuilder()
+
+
+class MessageFeedbackRequestBodyBuilder:
+    def __init__(self):
+        self._message_feedback_request_body = MessageFeedbackRequestBody()
+
+    def build(self) -> MessageFeedbackRequestBody:
+        return self._message_feedback_request_body
+
+    def rating(self, rating: str) -> MessageFeedbackRequestBodyBuilder:
+        if rating not in ("like", "dislike", "null"):
+            raise ValueError("Rating must be one of 'like', 'dislike', 'null'")
+        self._message_feedback_request_body.rating = rating
+        return self
+
+    def user(self, user: str) -> MessageFeedbackRequestBodyBuilder:
+        self._message_feedback_request_body.user = user
+        return self

dify_oapi/api/dify/v1/model/message_feedback_response.py

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

dify_oapi/api/dify/v1/model/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/dify/v1/model/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/dify/v1/model/text_to_audio_response.py

@@ -0,0 +1,4 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class TextToAudioResponse(BaseResponse): ...

dify_oapi/api/dify/v1/model/upload_file_body.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class UploadFileBody(BaseModel):
+    user: str | None = None
+
+    @staticmethod
+    def builder() -> UploadFileBodyBuilder:
+        return UploadFileBodyBuilder()
+
+
+class UploadFileBodyBuilder:
+    def __init__(self):
+        self._upload_file_body = UploadFileBody()
+
+    def build(self):
+        return self._upload_file_body
+
+    def user(self, user: str) -> UploadFileBodyBuilder:
+        self._upload_file_body.user = user
+        return self

dify_oapi/api/dify/v1/model/upload_file_request.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from io import BytesIO
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .upload_file_body import UploadFileBody
+
+
+class UploadFileRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.file: BytesIO | None = None
+        self.request_body: UploadFileBody | None = None
+
+    @staticmethod
+    def builder() -> UploadFileRequestBuilder:
+        return UploadFileRequestBuilder()
+
+
+class UploadFileRequestBuilder:
+    def __init__(self) -> None:
+        upload_file_request = UploadFileRequest()
+        upload_file_request.http_method = HttpMethod.POST
+        upload_file_request.uri = "/v1/files/upload"
+        self._upload_file_request: UploadFileRequest = upload_file_request
+
+    def build(self) -> UploadFileRequest:
+        return self._upload_file_request
+
+    def file(self, file: BytesIO, file_name: str | None = None) -> UploadFileRequestBuilder:
+        self._upload_file_request.file = file
+        if file_name is None:
+            file_name = "upload"
+        self._upload_file_request.files = {"file": (file_name, file)}
+        return self
+
+    def request_body(self, request_body: UploadFileBody) -> UploadFileRequestBuilder:
+        self._upload_file_request.request_body = request_body
+        self._upload_file_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

dify_oapi/api/dify/v1/model/upload_file_response.py

@@ -0,0 +1,11 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class UploadFileResponse(BaseResponse):
+    id: str | None = None
+    name: str | None = None
+    size: int | None = None
+    extension: str | None = None
+    mime_type: str | None = None
+    created_by: str | None = None
+    created_at: int | None = None

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

@@ -0,0 +1,6 @@
+from .meta import *  # noqa 403
+from .file import *  # noqa 403
+from .audio import *  # noqa 403
+from .parameter import *  # noqa 403
+from .message import *  # noqa 403
+from .info import *  # noqa 403

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

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

dify_oapi/api/dify/v1/resource/file.py

@@ -0,0 +1,17 @@
+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.upload_file_request import UploadFileRequest
+from ..model.upload_file_response import UploadFileResponse
+
+
+class File:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def upload(self, request: UploadFileRequest, option: RequestOption | None = None) -> UploadFileResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UploadFileResponse, option=option)
+
+    async def aupload(self, request: UploadFileRequest, option: RequestOption | None = None) -> UploadFileResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=UploadFileResponse, option=option)

dify_oapi/api/dify/v1/resource/info.py

@@ -0,0 +1,19 @@
+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_info_request import GetInfoRequest
+from ..model.get_info_response import GetInfoResponse
+
+
+class Info:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def get(self, request: GetInfoRequest, option: RequestOption | None = None) -> GetInfoResponse:
+        # Send request
+        return Transport.execute(self.config, request, unmarshal_as=GetInfoResponse, option=option)
+
+    async def aget(self, request: GetInfoRequest, option: RequestOption | None = None) -> GetInfoResponse:
+        # Send request
+        return await ATransport.aexecute(self.config, request, unmarshal_as=GetInfoResponse, option=option)

dify_oapi/api/dify/v1/resource/message.py

@@ -0,0 +1,21 @@
+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.message_feedback_request import MessageFeedbackRequest
+from ..model.message_feedback_response import MessageFeedbackResponse
+
+
+class Message:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def feedback(self, request: MessageFeedbackRequest, option: RequestOption | None = None) -> MessageFeedbackResponse:
+        # Send request
+        return Transport.execute(self.config, request, unmarshal_as=MessageFeedbackResponse, option=option)
+
+    async def afeedback(
+        self, request: MessageFeedbackRequest, option: RequestOption | None = None
+    ) -> MessageFeedbackResponse:
+        # Send request
+        return await ATransport.aexecute(self.config, request, unmarshal_as=MessageFeedbackResponse, option=option)

dify_oapi/api/dify/v1/resource/meta.py

@@ -0,0 +1,17 @@
+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_meta_request import GetMetaRequest
+from ..model.get_meta_response import GetMetaResponse
+
+
+class Meta:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def get(self, request: GetMetaRequest, option: RequestOption | None = None) -> GetMetaResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetMetaResponse, option=option)
+
+    async def aget(self, request: GetMetaRequest, option: RequestOption | None = None) -> GetMetaResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=GetMetaResponse, option=option)

dify_oapi/api/dify/v1/resource/parameter.py

@@ -0,0 +1,19 @@
+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_parameter_request import GetParameterRequest
+from ..model.get_parameter_response import GetParameterResponse
+
+
+class Parameter:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def get(self, request: GetParameterRequest, option: RequestOption | None = None) -> GetParameterResponse:
+        # Send request
+        return Transport.execute(self.config, request, unmarshal_as=GetParameterResponse, option=option)
+
+    async def aget(self, request: GetParameterRequest, option: RequestOption | None = None) -> GetParameterResponse:
+        # Send request
+        return await ATransport.aexecute(self.config, request, unmarshal_as=GetParameterResponse, option=option)

dify_oapi/api/dify/v1/version.py

@@ -0,0 +1,13 @@
+from dify_oapi.core.model.config import Config
+
+from .resource import Audio, File, Info, Message, Meta, Parameter
+
+
+class V1:
+    def __init__(self, config: Config):
+        self.meta: Meta = Meta(config)
+        self.file: File = File(config)
+        self.audio: Audio = Audio(config)
+        self.parameter: Parameter = Parameter(config)
+        self.message: Message = Message(config)
+        self.info: Info = Info(config)

dify_oapi/api/knowledge_base/service.py

@@ -0,0 +1,8 @@
+from dify_oapi.core.model.config import Config
+
+from .v1.version import V1
+
+
+class KnowledgeBaseService:
+    def __init__(self, config: Config) -> None:
+        self.v1: V1 = V1(config)

dify_oapi/api/knowledge_base/v1/model/dataset/__init__.py

@@ -0,0 +1,49 @@
+from ..metadata.metadata_info import MetadataInfo
+from ..tag.tag_info import TagInfo
+from .create_request import CreateRequest
+from .create_request_body import CreateRequestBody
+from .create_response import CreateResponse
+from .dataset_info import DatasetInfo
+from .delete_request import DeleteRequest
+from .delete_response import DeleteResponse
+from .external_knowledge_info import ExternalKnowledgeInfo
+from .filter_condition import FilterCondition
+from .get_request import GetRequest
+from .get_response import GetResponse
+from .list_request import ListRequest
+from .list_response import ListResponse
+from .metadata_filtering_conditions import MetadataFilteringConditions
+from .reranking_model import RerankingModel
+from .retrieval_model import RetrievalModel
+from .retrieve_request import RetrieveRequest
+from .retrieve_request_body import RetrieveRequestBody
+from .retrieve_response import RetrieveResponse
+from .update_request import UpdateRequest
+from .update_request_body import UpdateRequestBody
+from .update_response import UpdateResponse
+
+__all__ = [
+    "CreateRequest",
+    "CreateRequestBody",
+    "CreateResponse",
+    "DatasetInfo",
+    "DeleteRequest",
+    "DeleteResponse",
+    "ExternalKnowledgeInfo",
+    "FilterCondition",
+    "GetRequest",
+    "GetResponse",
+    "ListRequest",
+    "ListResponse",
+    "MetadataFilteringConditions",
+    "MetadataInfo",
+    "RerankingModel",
+    "RetrieveRequest",
+    "RetrieveRequestBody",
+    "RetrieveResponse",
+    "RetrievalModel",
+    "TagInfo",
+    "UpdateRequest",
+    "UpdateRequestBody",
+    "UpdateResponse",
+]

dify_oapi/api/knowledge_base/v1/model/dataset/create_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_request_body import CreateRequestBody
+
+
+class CreateRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.request_body: CreateRequestBody | None = None
+
+    @staticmethod
+    def builder() -> CreateRequestBuilder:
+        return CreateRequestBuilder()
+
+
+class CreateRequestBuilder:
+    def __init__(self):
+        create_request = CreateRequest()
+        create_request.http_method = HttpMethod.POST
+        create_request.uri = "/v1/datasets"
+        self._create_request = create_request
+
+    def build(self) -> CreateRequest:
+        return self._create_request
+
+    def request_body(self, request_body: CreateRequestBody) -> CreateRequestBuilder:
+        self._create_request.request_body = request_body
+        self._create_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

dify_oapi/api/knowledge_base/v1/model/dataset/create_request_body.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel
+
+from .retrieval_model import RetrievalModel
+
+
+class CreateRequestBody(BaseModel):
+    name: str | None = None
+    description: str | None = None
+    indexing_technique: str | None = None
+    permission: str | None = None
+    provider: str | None = None
+    external_knowledge_api_id: str | None = None
+    external_knowledge_id: str | None = None
+    embedding_model: str | None = None
+    embedding_model_provider: str | None = None
+    retrieval_model: RetrievalModel | None = None
+
+    @staticmethod
+    def builder() -> CreateRequestBodyBuilder:
+        return CreateRequestBodyBuilder()
+
+
+class CreateRequestBodyBuilder:
+    def __init__(self):
+        create_request_body = CreateRequestBody()
+        self._create_request_body = create_request_body
+
+    def build(self) -> CreateRequestBody:
+        return self._create_request_body
+
+    def name(self, name: str) -> CreateRequestBodyBuilder:
+        self._create_request_body.name = name
+        return self
+
+    def description(self, description: str) -> CreateRequestBodyBuilder:
+        self._create_request_body.description = description
+        return self
+
+    def indexing_technique(self, indexing_technique: Literal["high_quality", "economy"]) -> CreateRequestBodyBuilder:
+        self._create_request_body.indexing_technique = indexing_technique
+        return self
+
+    def permission(self, permission: str) -> CreateRequestBodyBuilder:
+        self._create_request_body.permission = permission
+        return self
+
+    def provider(self, provider: str) -> CreateRequestBodyBuilder:
+        self._create_request_body.provider = provider
+        return self
+
+    def external_knowledge_api_id(self, external_knowledge_api_id: str) -> CreateRequestBodyBuilder:
+        self._create_request_body.external_knowledge_api_id = external_knowledge_api_id
+        return self
+
+    def external_knowledge_id(self, external_knowledge_id: str) -> CreateRequestBodyBuilder:
+        self._create_request_body.external_knowledge_id = external_knowledge_id
+        return self
+
+    def embedding_model(self, embedding_model: str) -> CreateRequestBodyBuilder:
+        self._create_request_body.embedding_model = embedding_model
+        return self
+
+    def embedding_model_provider(self, embedding_model_provider: str) -> CreateRequestBodyBuilder:
+        self._create_request_body.embedding_model_provider = embedding_model_provider
+        return self
+
+    def retrieval_model(self, retrieval_model: RetrievalModel) -> CreateRequestBodyBuilder:
+        self._create_request_body.retrieval_model = retrieval_model
+        return self

dify_oapi/api/knowledge_base/v1/model/dataset/create_response.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .dataset_info import DatasetInfo
+
+
+class CreateResponse(DatasetInfo, BaseResponse):
+    """Response model for dataset creation API"""
+
+    pass