dify-oapi2 0.1.0__py3-none-any.whl

dify_oapi/api/knowledge_base/v1/model/document/update_by_file_request.py

@@ -0,0 +1,53 @@
+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 .update_by_file_request_body import UpdateByFileRequestBody
+
+
+class UpdateByFileRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.document_id: str | None = None
+        self.request_body: UpdateByFileRequestBody | None = None
+        self.file: BytesIO | None = None
+
+    @staticmethod
+    def builder() -> UpdateByFileRequestBuilder:
+        return UpdateByFileRequestBuilder()
+
+
+class UpdateByFileRequestBuilder:
+    def __init__(self) -> None:
+        update_by_file_request = UpdateByFileRequest()
+        update_by_file_request.http_method = HttpMethod.POST
+        update_by_file_request.uri = "/v1/datasets/:dataset_id/documents/:document_id/update-by-file"
+        self._update_by_file_request = update_by_file_request
+
+    def build(self) -> UpdateByFileRequest:
+        return self._update_by_file_request
+
+    def dataset_id(self, dataset_id: str) -> UpdateByFileRequestBuilder:
+        self._update_by_file_request.dataset_id = dataset_id
+        self._update_by_file_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def document_id(self, document_id: str) -> UpdateByFileRequestBuilder:
+        self._update_by_file_request.document_id = document_id
+        self._update_by_file_request.paths["document_id"] = document_id
+        return self
+
+    def request_body(self, request_body: UpdateByFileRequestBody) -> UpdateByFileRequestBuilder:
+        self._update_by_file_request.request_body = request_body
+        self._update_by_file_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self
+
+    def file(self, file: BytesIO, file_name: str | None = None) -> UpdateByFileRequestBuilder:
+        self._update_by_file_request.file = file
+        file_name = file_name or "upload"
+        self._update_by_file_request.files = {"file": (file_name, file)}
+        return self

dify_oapi/api/knowledge_base/v1/model/document/update_by_file_request_body.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .update_by_file_request_body_data import UpdateByFileRequestBodyData
+
+
+class UpdateByFileRequestBody(BaseModel):
+    data: str | None = None
+
+    @staticmethod
+    def builder() -> UpdateByFileRequestBodyBuilder:
+        return UpdateByFileRequestBodyBuilder()
+
+
+class UpdateByFileRequestBodyBuilder:
+    def __init__(self):
+        update_by_file_request_body = UpdateByFileRequestBody()
+        self._update_by_file_request_body = update_by_file_request_body
+
+    def build(self) -> UpdateByFileRequestBody:
+        return self._update_by_file_request_body
+
+    def data(self, data: UpdateByFileRequestBodyData) -> UpdateByFileRequestBodyBuilder:
+        self._update_by_file_request_body.data = data.model_dump_json(exclude_none=True)
+        return self

dify_oapi/api/knowledge_base/v1/model/document/update_by_file_request_body_data.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel
+
+from .process_rule import ProcessRule
+
+
+class UpdateByFileRequestBodyData(BaseModel):
+    name: str | None = None
+    indexing_technique: str | None = None
+    process_rule: ProcessRule | None = None
+
+    @staticmethod
+    def builder() -> UpdateByFileRequestBodyDataBuilder:
+        return UpdateByFileRequestBodyDataBuilder()
+
+
+class UpdateByFileRequestBodyDataBuilder:
+    def __init__(self):
+        update_by_file_request_body_data = UpdateByFileRequestBodyData()
+        self._update_by_file_request_body_data = update_by_file_request_body_data
+
+    def build(self) -> UpdateByFileRequestBodyData:
+        return self._update_by_file_request_body_data
+
+    def name(self, name: str) -> UpdateByFileRequestBodyDataBuilder:
+        self._update_by_file_request_body_data.name = name
+        return self
+
+    def indexing_technique(
+        self, indexing_technique: Literal["high_quality", "economy"]
+    ) -> UpdateByFileRequestBodyDataBuilder:
+        self._update_by_file_request_body_data.indexing_technique = indexing_technique
+        return self
+
+    def process_rule(self, process_rule: ProcessRule) -> UpdateByFileRequestBodyDataBuilder:
+        self._update_by_file_request_body_data.process_rule = process_rule
+        return self

dify_oapi/api/knowledge_base/v1/model/document/update_by_file_response.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .document_info import DocumentInfo
+
+
+class UpdateByFileResponse(BaseResponse):
+    """Response model for update document by file API"""
+
+    document: DocumentInfo | None = None
+    batch: str | None = None

dify_oapi/api/knowledge_base/v1/model/document/update_by_text_request.py

@@ -0,0 +1,55 @@
+"""Update document by text request model."""
+
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .update_by_text_request_body import UpdateByTextRequestBody
+
+
+class UpdateByTextRequest(BaseRequest):
+    """Request model for updating document by text."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.document_id: str | None = None
+        self.request_body: UpdateByTextRequestBody | None = None
+
+    @staticmethod
+    def builder() -> UpdateByTextRequestBuilder:
+        """Create a new UpdateByTextRequestBuilder instance."""
+        return UpdateByTextRequestBuilder()
+
+
+class UpdateByTextRequestBuilder:
+    """Builder for UpdateByTextRequest."""
+
+    def __init__(self) -> None:
+        update_by_text_request = UpdateByTextRequest()
+        update_by_text_request.http_method = HttpMethod.POST
+        update_by_text_request.uri = "/v1/datasets/:dataset_id/documents/:document_id/update-by-text"
+        self._update_by_text_request = update_by_text_request
+
+    def build(self) -> UpdateByTextRequest:
+        """Build the UpdateByTextRequest instance."""
+        return self._update_by_text_request
+
+    def dataset_id(self, dataset_id: str) -> UpdateByTextRequestBuilder:
+        """Set the dataset ID."""
+        self._update_by_text_request.dataset_id = dataset_id
+        self._update_by_text_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def document_id(self, document_id: str) -> UpdateByTextRequestBuilder:
+        """Set the document ID."""
+        self._update_by_text_request.document_id = document_id
+        self._update_by_text_request.paths["document_id"] = document_id
+        return self
+
+    def request_body(self, request_body: UpdateByTextRequestBody) -> UpdateByTextRequestBuilder:
+        """Set the request body."""
+        self._update_by_text_request.request_body = request_body
+        self._update_by_text_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

dify_oapi/api/knowledge_base/v1/model/document/update_by_text_request_body.py

@@ -0,0 +1,46 @@
+"""Update document by text request body model."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .process_rule import ProcessRule
+
+
+class UpdateByTextRequestBody(BaseModel):
+    """Request body model for updating document by text."""
+
+    name: str | None = None
+    text: str | None = None
+    process_rule: ProcessRule | None = None
+
+    @staticmethod
+    def builder() -> UpdateByTextRequestBodyBuilder:
+        """Create a new UpdateByTextRequestBodyBuilder instance."""
+        return UpdateByTextRequestBodyBuilder()
+
+
+class UpdateByTextRequestBodyBuilder:
+    """Builder for UpdateByTextRequestBody."""
+
+    def __init__(self) -> None:
+        self._update_by_text_request_body = UpdateByTextRequestBody()
+
+    def build(self) -> UpdateByTextRequestBody:
+        """Build the UpdateByTextRequestBody instance."""
+        return self._update_by_text_request_body
+
+    def name(self, name: str) -> UpdateByTextRequestBodyBuilder:
+        """Set the document name."""
+        self._update_by_text_request_body.name = name
+        return self
+
+    def text(self, text: str) -> UpdateByTextRequestBodyBuilder:
+        """Set the document text content."""
+        self._update_by_text_request_body.text = text
+        return self
+
+    def process_rule(self, process_rule: ProcessRule) -> UpdateByTextRequestBodyBuilder:
+        """Set the processing rule."""
+        self._update_by_text_request_body.process_rule = process_rule
+        return self

dify_oapi/api/knowledge_base/v1/model/document/update_by_text_response.py

@@ -0,0 +1,14 @@
+"""Update document by text response model."""
+
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .document_info import DocumentInfo
+
+
+class UpdateByTextResponse(BaseResponse):
+    """Response model for updating document by text."""
+
+    document: DocumentInfo | None = None
+    batch: str | None = None

dify_oapi/api/knowledge_base/v1/model/document/update_status_request.py

@@ -0,0 +1,55 @@
+"""Update status request model for document API."""
+
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .update_status_request_body import UpdateStatusRequestBody
+
+
+class UpdateStatusRequest(BaseRequest):
+    """Request model for updating document status."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.action: str | None = None
+        self.request_body: UpdateStatusRequestBody | None = None
+
+    @staticmethod
+    def builder() -> UpdateStatusRequestBuilder:
+        """Create a new UpdateStatusRequestBuilder instance."""
+        return UpdateStatusRequestBuilder()
+
+
+class UpdateStatusRequestBuilder:
+    """Builder for UpdateStatusRequest."""
+
+    def __init__(self) -> None:
+        update_status_request = UpdateStatusRequest()
+        update_status_request.http_method = HttpMethod.PATCH
+        update_status_request.uri = "/v1/datasets/:dataset_id/documents/status/:action"
+        self._update_status_request = update_status_request
+
+    def build(self) -> UpdateStatusRequest:
+        """Build the UpdateStatusRequest instance."""
+        return self._update_status_request
+
+    def dataset_id(self, dataset_id: str) -> UpdateStatusRequestBuilder:
+        """Set the dataset ID."""
+        self._update_status_request.dataset_id = dataset_id
+        self._update_status_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def action(self, action: str) -> UpdateStatusRequestBuilder:
+        """Set the action."""
+        self._update_status_request.action = action
+        self._update_status_request.paths["action"] = action
+        return self
+
+    def request_body(self, request_body: UpdateStatusRequestBody) -> UpdateStatusRequestBuilder:
+        """Set the request body."""
+        self._update_status_request.request_body = request_body
+        self._update_status_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

dify_oapi/api/knowledge_base/v1/model/document/update_status_request_body.py

@@ -0,0 +1,32 @@
+"""Update status request body model for document API."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class UpdateStatusRequestBody(BaseModel):
+    """Request body model for updating document status."""
+
+    document_ids: list[str] | None = None
+
+    @staticmethod
+    def builder() -> UpdateStatusRequestBodyBuilder:
+        """Create a new UpdateStatusRequestBodyBuilder instance."""
+        return UpdateStatusRequestBodyBuilder()
+
+
+class UpdateStatusRequestBodyBuilder:
+    """Builder for UpdateStatusRequestBody."""
+
+    def __init__(self) -> None:
+        self._update_status_request_body = UpdateStatusRequestBody()
+
+    def build(self) -> UpdateStatusRequestBody:
+        """Build the UpdateStatusRequestBody instance."""
+        return self._update_status_request_body
+
+    def document_ids(self, document_ids: list[str]) -> UpdateStatusRequestBodyBuilder:
+        """Set the document IDs."""
+        self._update_status_request_body.document_ids = document_ids
+        return self

dify_oapi/api/knowledge_base/v1/model/document/update_status_response.py

@@ -0,0 +1,9 @@
+"""Update status response model for document API."""
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class UpdateStatusResponse(BaseResponse):
+    """Response model for updating document status."""
+
+    result: str | None = None

dify_oapi/api/knowledge_base/v1/model/document/upload_file_info.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class UploadFileInfo(BaseModel):
+    """Upload file information model for document file details."""
+
+    id: str | None = None
+    name: str | None = None
+    size: int | None = None
+    extension: str | None = None
+    url: str | None = None
+    download_url: str | None = None
+    mime_type: str | None = None
+    created_by: str | None = None
+    created_at: float | None = None
+
+    @staticmethod
+    def builder() -> UploadFileInfoBuilder:
+        return UploadFileInfoBuilder()
+
+
+class UploadFileInfoBuilder:
+    def __init__(self):
+        self._upload_file_info = UploadFileInfo()
+
+    def build(self) -> UploadFileInfo:
+        return self._upload_file_info
+
+    def id(self, id: str) -> UploadFileInfoBuilder:
+        self._upload_file_info.id = id
+        return self
+
+    def name(self, name: str) -> UploadFileInfoBuilder:
+        self._upload_file_info.name = name
+        return self
+
+    def size(self, size: int) -> UploadFileInfoBuilder:
+        self._upload_file_info.size = size
+        return self
+
+    def extension(self, extension: str) -> UploadFileInfoBuilder:
+        self._upload_file_info.extension = extension
+        return self
+
+    def url(self, url: str) -> UploadFileInfoBuilder:
+        self._upload_file_info.url = url
+        return self
+
+    def download_url(self, download_url: str) -> UploadFileInfoBuilder:
+        self._upload_file_info.download_url = download_url
+        return self
+
+    def mime_type(self, mime_type: str) -> UploadFileInfoBuilder:
+        self._upload_file_info.mime_type = mime_type
+        return self
+
+    def created_by(self, created_by: str) -> UploadFileInfoBuilder:
+        self._upload_file_info.created_by = created_by
+        return self
+
+    def created_at(self, created_at: float) -> UploadFileInfoBuilder:
+        self._upload_file_info.created_at = created_at
+        return self

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

@@ -0,0 +1,35 @@
+from .create_request import CreateRequest
+from .create_request_body import CreateRequestBody
+from .create_response import CreateResponse
+from .delete_request import DeleteRequest
+from .delete_response import DeleteResponse
+from .list_request import ListRequest
+from .list_response import ListResponse
+from .toggle_builtin_request import ToggleBuiltinRequest
+from .toggle_builtin_response import ToggleBuiltinResponse
+from .update_document_request import UpdateDocumentRequest
+from .update_document_request_body import DocumentMetadata, OperationData, UpdateDocumentRequestBody
+from .update_document_response import UpdateDocumentResponse
+from .update_request import UpdateRequest
+from .update_request_body import UpdateRequestBody
+from .update_response import UpdateResponse
+
+__all__ = [
+    "CreateRequest",
+    "CreateRequestBody",
+    "CreateResponse",
+    "DeleteRequest",
+    "DeleteResponse",
+    "ListRequest",
+    "ListResponse",
+    "ToggleBuiltinRequest",
+    "ToggleBuiltinResponse",
+    "UpdateDocumentRequest",
+    "UpdateDocumentRequestBody",
+    "DocumentMetadata",
+    "OperationData",
+    "UpdateDocumentResponse",
+    "UpdateRequest",
+    "UpdateRequestBody",
+    "UpdateResponse",
+]

dify_oapi/api/knowledge_base/v1/model/metadata/create_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 .create_request_body import CreateRequestBody
+
+
+class CreateRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.dataset_id: str | None = None
+        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/:dataset_id/metadata"
+        self._create_request = create_request
+
+    def build(self) -> CreateRequest:
+        return self._create_request
+
+    def dataset_id(self, dataset_id: str) -> CreateRequestBuilder:
+        self._create_request.dataset_id = dataset_id
+        self._create_request.paths["dataset_id"] = dataset_id
+        return self
+
+    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/metadata/create_request_body.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel
+
+
+class CreateRequestBody(BaseModel):
+    type: Literal["string", "number", "time"] | None = None
+    name: str | 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 type(self, type: Literal["string", "number", "time"]) -> CreateRequestBodyBuilder:
+        self._create_request_body.type = type
+        return self
+
+    def name(self, name: str) -> CreateRequestBodyBuilder:
+        self._create_request_body.name = name
+        return self

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

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from dify_oapi.api.knowledge_base.v1.model.metadata.metadata_info import MetadataInfo
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class CreateResponse(BaseResponse):
+    id: str | None = None
+    type: str | None = None
+    name: str | None = None
+
+    def to_metadata_info(self) -> MetadataInfo:
+        return MetadataInfo(id=self.id or "", type=self.type or "", name=self.name or "")

dify_oapi/api/knowledge_base/v1/model/metadata/delete_request.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class DeleteRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.metadata_id: str | None = None
+
+    @staticmethod
+    def builder() -> DeleteRequestBuilder:
+        return DeleteRequestBuilder()
+
+
+class DeleteRequestBuilder:
+    def __init__(self):
+        delete_request = DeleteRequest()
+        delete_request.http_method = HttpMethod.DELETE
+        delete_request.uri = "/v1/datasets/:dataset_id/metadata/:metadata_id"
+        self._delete_request = delete_request
+
+    def build(self) -> DeleteRequest:
+        return self._delete_request
+
+    def dataset_id(self, dataset_id: str) -> DeleteRequestBuilder:
+        self._delete_request.dataset_id = dataset_id
+        self._delete_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def metadata_id(self, metadata_id: str) -> DeleteRequestBuilder:
+        self._delete_request.metadata_id = metadata_id
+        self._delete_request.paths["metadata_id"] = metadata_id
+        return self

dify_oapi/api/knowledge_base/v1/model/metadata/delete_response.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class DeleteResponse(BaseResponse):
+    """Empty response for 204 No Content"""

dify_oapi/api/knowledge_base/v1/model/metadata/list_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 ListRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.dataset_id: str | None = None
+
+    @staticmethod
+    def builder() -> ListRequestBuilder:
+        return ListRequestBuilder()
+
+
+class ListRequestBuilder:
+    def __init__(self):
+        list_request = ListRequest()
+        list_request.http_method = HttpMethod.GET
+        list_request.uri = "/v1/datasets/:dataset_id/metadata"
+        self._list_request = list_request
+
+    def build(self) -> ListRequest:
+        return self._list_request
+
+    def dataset_id(self, dataset_id: str) -> ListRequestBuilder:
+        self._list_request.dataset_id = dataset_id
+        self._list_request.paths["dataset_id"] = dataset_id
+        return self

dify_oapi/api/knowledge_base/v1/model/metadata/list_response.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dify_oapi.api.knowledge_base.v1.model.metadata.metadata_info import MetadataInfo
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class ListResponse(BaseResponse):
+    doc_metadata: list[MetadataInfo] | None = None
+    built_in_field_enabled: bool | None = None

dify_oapi/api/knowledge_base/v1/model/metadata/metadata_info.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class MetadataInfo(BaseModel):
+    id: str
+    name: str
+    type: str
+    use_count: int | None = None
+
+    @staticmethod
+    def builder() -> MetadataInfoBuilder:
+        return MetadataInfoBuilder()
+
+
+class MetadataInfoBuilder:
+    def __init__(self):
+        self._metadata_info = MetadataInfo(id="", name="", type="")
+
+    def build(self) -> MetadataInfo:
+        return self._metadata_info
+
+    def id(self, id: str) -> MetadataInfoBuilder:
+        self._metadata_info.id = id
+        return self
+
+    def name(self, name: str) -> MetadataInfoBuilder:
+        self._metadata_info.name = name
+        return self
+
+    def type(self, type: str) -> MetadataInfoBuilder:
+        self._metadata_info.type = type
+        return self
+
+    def use_count(self, use_count: int) -> MetadataInfoBuilder:
+        self._metadata_info.use_count = use_count
+        return self