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

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

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .retriever_resource import RetrieverResource
+from .usage import Usage
+
+
+class Metadata(BaseModel):
+    usage: Usage | None = None
+    retriever_resources: list[RetrieverResource] | None = None
+
+    @staticmethod
+    def builder() -> MetadataBuilder:
+        return MetadataBuilder()
+
+
+class MetadataBuilder:
+    def __init__(self):
+        self._metadata = Metadata()
+
+    def build(self) -> Metadata:
+        return self._metadata
+
+    def usage(self, usage: Usage) -> MetadataBuilder:
+        self._metadata.usage = usage
+        return self
+
+    def retriever_resources(self, retriever_resources: list[RetrieverResource]) -> MetadataBuilder:
+        self._metadata.retriever_resources = retriever_resources
+        return self

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

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class RetrieverResource(BaseModel):
+    position: int | None = None
+    dataset_id: str | None = None
+    dataset_name: str | None = None
+    document_id: str | None = None
+    document_name: str | None = None
+    segment_id: str | None = None
+    score: float | None = None
+    content: str | None = None
+
+    @staticmethod
+    def builder() -> RetrieverResourceBuilder:
+        return RetrieverResourceBuilder()
+
+
+class RetrieverResourceBuilder:
+    def __init__(self):
+        self._retriever_resource = RetrieverResource()
+
+    def build(self) -> RetrieverResource:
+        return self._retriever_resource
+
+    def position(self, position: int) -> RetrieverResourceBuilder:
+        self._retriever_resource.position = position
+        return self
+
+    def dataset_id(self, dataset_id: str) -> RetrieverResourceBuilder:
+        self._retriever_resource.dataset_id = dataset_id
+        return self
+
+    def dataset_name(self, dataset_name: str) -> RetrieverResourceBuilder:
+        self._retriever_resource.dataset_name = dataset_name
+        return self
+
+    def document_id(self, document_id: str) -> RetrieverResourceBuilder:
+        self._retriever_resource.document_id = document_id
+        return self
+
+    def document_name(self, document_name: str) -> RetrieverResourceBuilder:
+        self._retriever_resource.document_name = document_name
+        return self
+
+    def segment_id(self, segment_id: str) -> RetrieverResourceBuilder:
+        self._retriever_resource.segment_id = segment_id
+        return self
+
+    def score(self, score: float) -> RetrieverResourceBuilder:
+        self._retriever_resource.score = score
+        return self
+
+    def content(self, content: str) -> RetrieverResourceBuilder:
+        self._retriever_resource.content = content
+        return self

dify_oapi/api/completion/v1/model/completion/send_message_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 .send_message_request_body import SendMessageRequestBody
+
+
+class SendMessageRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.request_body: SendMessageRequestBody | None = None
+
+    @staticmethod
+    def builder() -> SendMessageRequestBuilder:
+        return SendMessageRequestBuilder()
+
+
+class SendMessageRequestBuilder:
+    def __init__(self) -> None:
+        send_message_request = SendMessageRequest()
+        send_message_request.http_method = HttpMethod.POST
+        send_message_request.uri = "/v1/completion-messages"
+        self._send_message_request: SendMessageRequest = send_message_request
+
+    def request_body(self, request_body: SendMessageRequestBody) -> SendMessageRequestBuilder:
+        self._send_message_request.request_body = request_body
+        self._send_message_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self
+
+    def build(self) -> SendMessageRequest:
+        return self._send_message_request

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

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .completion_inputs import CompletionInputs
+from .completion_types import FileType, ResponseMode, TransferMethod
+
+
+class FileInfo(BaseModel):
+    type: FileType | None = None
+    transfer_method: TransferMethod | None = None
+    url: str | None = None
+    upload_file_id: str | None = None
+
+    @staticmethod
+    def builder() -> FileInfoBuilder:
+        return FileInfoBuilder()
+
+
+class FileInfoBuilder:
+    def __init__(self):
+        self._file_info = FileInfo()
+
+    def build(self) -> FileInfo:
+        return self._file_info
+
+    def type(self, type_: FileType) -> FileInfoBuilder:
+        self._file_info.type = type_
+        return self
+
+    def transfer_method(self, transfer_method: TransferMethod) -> FileInfoBuilder:
+        self._file_info.transfer_method = transfer_method
+        return self
+
+    def url(self, url: str) -> FileInfoBuilder:
+        self._file_info.url = url
+        return self
+
+    def upload_file_id(self, upload_file_id: str) -> FileInfoBuilder:
+        self._file_info.upload_file_id = upload_file_id
+        return self
+
+
+class SendMessageRequestBody(BaseModel):
+    inputs: CompletionInputs | None = None
+    response_mode: ResponseMode | None = None
+    user: str | None = None
+    files: list[FileInfo] | None = None
+
+    @staticmethod
+    def builder() -> SendMessageRequestBodyBuilder:
+        return SendMessageRequestBodyBuilder()
+
+
+class SendMessageRequestBodyBuilder:
+    def __init__(self):
+        self._send_message_request_body = SendMessageRequestBody()
+
+    def build(self) -> SendMessageRequestBody:
+        return self._send_message_request_body
+
+    def inputs(self, inputs: CompletionInputs) -> SendMessageRequestBodyBuilder:
+        self._send_message_request_body.inputs = inputs
+        return self
+
+    def response_mode(self, response_mode: ResponseMode) -> SendMessageRequestBodyBuilder:
+        self._send_message_request_body.response_mode = response_mode
+        return self
+
+    def user(self, user: str) -> SendMessageRequestBodyBuilder:
+        self._send_message_request_body.user = user
+        return self
+
+    def files(self, files: list[FileInfo]) -> SendMessageRequestBodyBuilder:
+        self._send_message_request_body.files = files
+        return self

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

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .completion_message_info import CompletionMessageInfo
+
+
+class SendMessageResponse(CompletionMessageInfo, BaseResponse):
+    pass

dify_oapi/api/completion/v1/model/completion/stop_response_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 .stop_response_request_body import StopResponseRequestBody
+
+
+class StopResponseRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.request_body: StopResponseRequestBody | None = None
+        self.task_id: str | None = None
+
+    @staticmethod
+    def builder() -> StopResponseRequestBuilder:
+        return StopResponseRequestBuilder()
+
+
+class StopResponseRequestBuilder:
+    def __init__(self):
+        stop_response_request = StopResponseRequest()
+        stop_response_request.http_method = HttpMethod.POST
+        stop_response_request.uri = "/v1/completion-messages/:task_id/stop"
+        self._stop_response_request = stop_response_request
+
+    def build(self) -> StopResponseRequest:
+        return self._stop_response_request
+
+    def request_body(self, request_body: StopResponseRequestBody) -> StopResponseRequestBuilder:
+        self._stop_response_request.request_body = request_body
+        self._stop_response_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self
+
+    def task_id(self, task_id: str) -> StopResponseRequestBuilder:
+        self._stop_response_request.task_id = task_id
+        self._stop_response_request.paths["task_id"] = task_id
+        return self

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

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

dify_oapi/api/completion/v1/model/{stop_completion_response.py → completion/stop_response_response.py}

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 from dify_oapi.core.model.base_response import BaseResponse
 
 
-class StopCompletionResponse(BaseResponse):
+class StopResponseResponse(BaseResponse):
     result: str | None = None

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

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class Usage(BaseModel):
+    prompt_tokens: int | None = None
+    prompt_unit_price: str | None = None
+    prompt_price_unit: str | None = None
+    prompt_price: str | None = None
+    completion_tokens: int | None = None
+    completion_unit_price: str | None = None
+    completion_price_unit: str | None = None
+    completion_price: str | None = None
+    total_tokens: int | None = None
+    total_price: str | None = None
+    currency: str | None = None
+    latency: float | None = None
+
+    @staticmethod
+    def builder() -> UsageBuilder:
+        return UsageBuilder()
+
+
+class UsageBuilder:
+    def __init__(self):
+        self._usage = Usage()
+
+    def build(self) -> Usage:
+        return self._usage
+
+    def prompt_tokens(self, prompt_tokens: int) -> UsageBuilder:
+        self._usage.prompt_tokens = prompt_tokens
+        return self
+
+    def prompt_unit_price(self, prompt_unit_price: str) -> UsageBuilder:
+        self._usage.prompt_unit_price = prompt_unit_price
+        return self
+
+    def prompt_price_unit(self, prompt_price_unit: str) -> UsageBuilder:
+        self._usage.prompt_price_unit = prompt_price_unit
+        return self
+
+    def prompt_price(self, prompt_price: str) -> UsageBuilder:
+        self._usage.prompt_price = prompt_price
+        return self
+
+    def completion_tokens(self, completion_tokens: int) -> UsageBuilder:
+        self._usage.completion_tokens = completion_tokens
+        return self
+
+    def completion_unit_price(self, completion_unit_price: str) -> UsageBuilder:
+        self._usage.completion_unit_price = completion_unit_price
+        return self
+
+    def completion_price_unit(self, completion_price_unit: str) -> UsageBuilder:
+        self._usage.completion_price_unit = completion_price_unit
+        return self
+
+    def completion_price(self, completion_price: str) -> UsageBuilder:
+        self._usage.completion_price = completion_price
+        return self
+
+    def total_tokens(self, total_tokens: int) -> UsageBuilder:
+        self._usage.total_tokens = total_tokens
+        return self
+
+    def total_price(self, total_price: str) -> UsageBuilder:
+        self._usage.total_price = total_price
+        return self
+
+    def currency(self, currency: str) -> UsageBuilder:
+        self._usage.currency = currency
+        return self
+
+    def latency(self, latency: float) -> UsageBuilder:
+        self._usage.latency = latency
+        return self

dify_oapi/api/completion/v1/model/feedback/feedback_info.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class FeedbackInfo(BaseModel):
+    id: str | None = None
+    rating: str | None = None
+    content: str | None = None
+    from_source: str | None = None
+    from_end_user_id: str | None = None
+    from_account_id: str | None = None
+    created_at: int | None = None
+
+    @staticmethod
+    def builder() -> FeedbackInfoBuilder:
+        return FeedbackInfoBuilder()
+
+
+class FeedbackInfoBuilder:
+    def __init__(self):
+        self._feedback_info = FeedbackInfo()
+
+    def build(self) -> FeedbackInfo:
+        return self._feedback_info
+
+    def id(self, id: str) -> FeedbackInfoBuilder:
+        self._feedback_info.id = id
+        return self
+
+    def rating(self, rating: str) -> FeedbackInfoBuilder:
+        self._feedback_info.rating = rating
+        return self
+
+    def content(self, content: str) -> FeedbackInfoBuilder:
+        self._feedback_info.content = content
+        return self
+
+    def from_source(self, from_source: str) -> FeedbackInfoBuilder:
+        self._feedback_info.from_source = from_source
+        return self
+
+    def from_end_user_id(self, from_end_user_id: str) -> FeedbackInfoBuilder:
+        self._feedback_info.from_end_user_id = from_end_user_id
+        return self
+
+    def from_account_id(self, from_account_id: str) -> FeedbackInfoBuilder:
+        self._feedback_info.from_account_id = from_account_id
+        return self
+
+    def created_at(self, created_at: int) -> FeedbackInfoBuilder:
+        self._feedback_info.created_at = created_at
+        return self

dify_oapi/api/completion/v1/model/feedback/get_feedbacks_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 GetFeedbacksRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def builder() -> GetFeedbacksRequestBuilder:
+        return GetFeedbacksRequestBuilder()
+
+
+class GetFeedbacksRequestBuilder:
+    def __init__(self):
+        get_feedbacks_request = GetFeedbacksRequest()
+        get_feedbacks_request.http_method = HttpMethod.GET
+        get_feedbacks_request.uri = "/v1/app/feedbacks"
+        self._get_feedbacks_request = get_feedbacks_request
+
+    def build(self) -> GetFeedbacksRequest:
+        return self._get_feedbacks_request
+
+    def page(self, page: str) -> GetFeedbacksRequestBuilder:
+        self._get_feedbacks_request.add_query("page", page)
+        return self
+
+    def limit(self, limit: str) -> GetFeedbacksRequestBuilder:
+        self._get_feedbacks_request.add_query("limit", limit)
+        return self

dify_oapi/api/completion/v1/model/feedback/get_feedbacks_response.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .feedback_info import FeedbackInfo
+
+
+class GetFeedbacksResponse(BaseResponse):
+    data: list[FeedbackInfo] | None = None

dify_oapi/api/completion/v1/model/feedback/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 .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/completion/v1/model/feedback/message_feedback_request_body.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from ..completion.completion_types import FeedbackRating
+
+
+class MessageFeedbackRequestBody(BaseModel):
+    rating: FeedbackRating | None = None
+    user: str | None = None
+    content: 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: FeedbackRating) -> MessageFeedbackRequestBodyBuilder:
+        self._message_feedback_request_body.rating = rating
+        return self
+
+    def user(self, user: str) -> MessageFeedbackRequestBodyBuilder:
+        self._message_feedback_request_body.user = user
+        return self
+
+    def content(self, content: str) -> MessageFeedbackRequestBodyBuilder:
+        self._message_feedback_request_body.content = content
+        return self

dify_oapi/api/completion/v1/model/feedback/message_feedback_response.py

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

dify_oapi/api/completion/v1/model/file/file_info.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class FileInfo(BaseModel):
+    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
+
+    @staticmethod
+    def builder() -> FileInfoBuilder:
+        return FileInfoBuilder()
+
+
+class FileInfoBuilder:
+    def __init__(self):
+        self._file_info = FileInfo()
+
+    def build(self) -> FileInfo:
+        return self._file_info
+
+    def id(self, id: str) -> FileInfoBuilder:
+        self._file_info.id = id
+        return self
+
+    def name(self, name: str) -> FileInfoBuilder:
+        self._file_info.name = name
+        return self
+
+    def size(self, size: int) -> FileInfoBuilder:
+        self._file_info.size = size
+        return self
+
+    def extension(self, extension: str) -> FileInfoBuilder:
+        self._file_info.extension = extension
+        return self
+
+    def mime_type(self, mime_type: str) -> FileInfoBuilder:
+        self._file_info.mime_type = mime_type
+        return self
+
+    def created_by(self, created_by: str) -> FileInfoBuilder:
+        self._file_info.created_by = created_by
+        return self
+
+    def created_at(self, created_at: int) -> FileInfoBuilder:
+        self._file_info.created_at = created_at
+        return self

dify_oapi/api/completion/v1/model/file/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_request_body import UploadFileRequestBody
+
+
+class UploadFileRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.request_body: UploadFileRequestBody | None = None
+        self.file: BytesIO | None = None
+
+    @staticmethod
+    def builder() -> UploadFileRequestBuilder:
+        return UploadFileRequestBuilder()
+
+
+class UploadFileRequestBuilder:
+    def __init__(self):
+        upload_file_request = UploadFileRequest()
+        upload_file_request.http_method = HttpMethod.POST
+        upload_file_request.uri = "/v1/files/upload"
+        self._upload_file_request = 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
+        file_name = file_name or "upload"
+        self._upload_file_request.files = {"file": (file_name, file)}
+        return self
+
+    def request_body(self, request_body: UploadFileRequestBody) -> UploadFileRequestBuilder:
+        self._upload_file_request.request_body = request_body
+        if request_body.user:
+            self._upload_file_request.body = {"user": request_body.user}
+        return self

dify_oapi/api/completion/v1/model/file/upload_file_request_body.py

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

dify_oapi/api/completion/v1/model/file/upload_file_response.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .file_info import FileInfo
+
+
+class UploadFileResponse(FileInfo, BaseResponse):
+    pass