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

dify_oapi/api/knowledge/v1/model/create_document_by_text_request_body.py

@@ -0,0 +1,73 @@
+"""Create document by text request body model."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .knowledge_types import DocumentForm, IndexingTechnique
+from .process_rule import ProcessRule
+from .retrieval_model import RetrievalModel
+
+
+class CreateDocumentByTextRequestBody(BaseModel):
+    """Request body model for create document by text API."""
+
+    name: str | None = None
+    text: str | None = None
+    indexing_technique: IndexingTechnique | None = None
+    doc_form: DocumentForm | None = None
+    doc_language: str | None = None
+    process_rule: ProcessRule | None = None
+    retrieval_model: RetrievalModel | None = None
+    embedding_model: str | None = None
+    embedding_model_provider: str | None = None
+
+    @staticmethod
+    def builder() -> CreateDocumentByTextRequestBodyBuilder:
+        return CreateDocumentByTextRequestBodyBuilder()
+
+
+class CreateDocumentByTextRequestBodyBuilder:
+    """Builder for CreateDocumentByTextRequestBody."""
+
+    def __init__(self) -> None:
+        self._create_document_by_text_request_body = CreateDocumentByTextRequestBody()
+
+    def build(self) -> CreateDocumentByTextRequestBody:
+        return self._create_document_by_text_request_body
+
+    def name(self, name: str) -> CreateDocumentByTextRequestBodyBuilder:
+        self._create_document_by_text_request_body.name = name
+        return self
+
+    def text(self, text: str) -> CreateDocumentByTextRequestBodyBuilder:
+        self._create_document_by_text_request_body.text = text
+        return self
+
+    def indexing_technique(self, indexing_technique: IndexingTechnique) -> CreateDocumentByTextRequestBodyBuilder:
+        self._create_document_by_text_request_body.indexing_technique = indexing_technique
+        return self
+
+    def process_rule(self, process_rule: ProcessRule) -> CreateDocumentByTextRequestBodyBuilder:
+        self._create_document_by_text_request_body.process_rule = process_rule
+        return self
+
+    def doc_form(self, doc_form: DocumentForm) -> CreateDocumentByTextRequestBodyBuilder:
+        self._create_document_by_text_request_body.doc_form = doc_form
+        return self
+
+    def doc_language(self, doc_language: str) -> CreateDocumentByTextRequestBodyBuilder:
+        self._create_document_by_text_request_body.doc_language = doc_language
+        return self
+
+    def retrieval_model(self, retrieval_model: RetrievalModel) -> CreateDocumentByTextRequestBodyBuilder:
+        self._create_document_by_text_request_body.retrieval_model = retrieval_model
+        return self
+
+    def embedding_model(self, embedding_model: str) -> CreateDocumentByTextRequestBodyBuilder:
+        self._create_document_by_text_request_body.embedding_model = embedding_model
+        return self
+
+    def embedding_model_provider(self, embedding_model_provider: str) -> CreateDocumentByTextRequestBodyBuilder:
+        self._create_document_by_text_request_body.embedding_model_provider = embedding_model_provider
+        return self

dify_oapi/api/{knowledge_base/v1/model/document/create_by_text_response.py → knowledge/v1/model/create_document_by_text_response.py}

@@ -1,12 +1,12 @@
-from __future__ import annotations
+"""Create document by text response model."""
 
 from dify_oapi.core.model.base_response import BaseResponse
 
 from .document_info import DocumentInfo
 
 
-class CreateByTextResponse(BaseResponse):
-    """Response model for create document by text API"""
+class CreateDocumentByTextResponse(BaseResponse):
+    """Response model for create document by text API."""
 
     document: DocumentInfo | None = None
     batch: str | None = None

dify_oapi/api/knowledge/v1/model/create_segment_request.py

@@ -0,0 +1,50 @@
+"""Create segment request model."""
+
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .create_segment_request_body import CreateSegmentRequestBody
+
+
+class CreateSegmentRequest(BaseRequest):
+    """Request model for create segment API."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.document_id: str | None = None
+        self.request_body: CreateSegmentRequestBody | None = None
+
+    @staticmethod
+    def builder() -> CreateSegmentRequestBuilder:
+        return CreateSegmentRequestBuilder()
+
+
+class CreateSegmentRequestBuilder:
+    """Builder for CreateSegmentRequest."""
+
+    def __init__(self) -> None:
+        create_segment_request = CreateSegmentRequest()
+        create_segment_request.http_method = HttpMethod.POST
+        create_segment_request.uri = "/v1/datasets/:dataset_id/documents/:document_id/segments"
+        self._create_segment_request = create_segment_request
+
+    def build(self) -> CreateSegmentRequest:
+        return self._create_segment_request
+
+    def dataset_id(self, dataset_id: str) -> CreateSegmentRequestBuilder:
+        self._create_segment_request.dataset_id = dataset_id
+        self._create_segment_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def document_id(self, document_id: str) -> CreateSegmentRequestBuilder:
+        self._create_segment_request.document_id = document_id
+        self._create_segment_request.paths["document_id"] = document_id
+        return self
+
+    def request_body(self, request_body: CreateSegmentRequestBody) -> CreateSegmentRequestBuilder:
+        self._create_segment_request.request_body = request_body
+        self._create_segment_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

dify_oapi/api/knowledge/v1/model/create_segment_request_body.py

@@ -0,0 +1,31 @@
+"""Create segment request body model."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .segment_content import SegmentContent
+
+
+class CreateSegmentRequestBody(BaseModel):
+    """Request body model for create segment API."""
+
+    segments: list[SegmentContent] | None = None
+
+    @staticmethod
+    def builder() -> CreateSegmentRequestBodyBuilder:
+        return CreateSegmentRequestBodyBuilder()
+
+
+class CreateSegmentRequestBodyBuilder:
+    """Builder for CreateSegmentRequestBody."""
+
+    def __init__(self) -> None:
+        self._create_segment_request_body = CreateSegmentRequestBody()
+
+    def build(self) -> CreateSegmentRequestBody:
+        return self._create_segment_request_body
+
+    def segments(self, segments: list[SegmentContent]) -> CreateSegmentRequestBodyBuilder:
+        self._create_segment_request_body.segments = segments
+        return self

dify_oapi/api/{knowledge_base/v1/model/segment/create_response.py → knowledge/v1/model/create_segment_response.py}

@@ -1,8 +1,11 @@
+"""Create segment response model."""
+
 from dify_oapi.core.model.base_response import BaseResponse
 
 from .segment_info import SegmentInfo
 
 
-class CreateResponse(BaseResponse):
+class CreateSegmentResponse(BaseResponse):
+    """Response model for create segment API."""
+
     data: list[SegmentInfo] | None = None
-    doc_form: str | None = None

dify_oapi/api/knowledge/v1/model/create_tag_request.py

@@ -0,0 +1,30 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .create_tag_request_body import CreateTagRequestBody
+
+
+class CreateTagRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.request_body: CreateTagRequestBody | None = None
+
+    @staticmethod
+    def builder() -> "CreateTagRequestBuilder":
+        return CreateTagRequestBuilder()
+
+
+class CreateTagRequestBuilder:
+    def __init__(self):
+        create_tag_request = CreateTagRequest()
+        create_tag_request.http_method = HttpMethod.POST
+        create_tag_request.uri = "/v1/datasets/tags"
+        self._create_tag_request = create_tag_request
+
+    def build(self) -> CreateTagRequest:
+        return self._create_tag_request
+
+    def request_body(self, request_body: CreateTagRequestBody) -> "CreateTagRequestBuilder":
+        self._create_tag_request.request_body = request_body
+        self._create_tag_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

dify_oapi/api/knowledge/v1/model/create_tag_request_body.py

@@ -0,0 +1,28 @@
+from pydantic import BaseModel
+
+from .knowledge_types import TagType
+
+
+class CreateTagRequestBody(BaseModel):
+    name: str | None = None
+    type: TagType | None = None
+
+    @staticmethod
+    def builder() -> "CreateTagRequestBodyBuilder":
+        return CreateTagRequestBodyBuilder()
+
+
+class CreateTagRequestBodyBuilder:
+    def __init__(self):
+        self._create_tag_request_body = CreateTagRequestBody()
+
+    def build(self) -> CreateTagRequestBody:
+        return self._create_tag_request_body
+
+    def name(self, name: str) -> "CreateTagRequestBodyBuilder":
+        self._create_tag_request_body.name = name
+        return self
+
+    def type(self, type_value: TagType) -> "CreateTagRequestBodyBuilder":
+        self._create_tag_request_body.type = type_value
+        return self

dify_oapi/api/knowledge/v1/model/create_tag_response.py

@@ -0,0 +1,7 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .tag_info import TagInfo
+
+
+class CreateTagResponse(TagInfo, BaseResponse):
+    pass

dify_oapi/api/knowledge/v1/model/data_source_info.py

@@ -0,0 +1,34 @@
+"""Data source info model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class DataSourceInfo(BaseModel):
+    """Data source info model with builder pattern."""
+
+    upload_file_id: Optional[str] = None
+    original_document_id: Optional[str] = None
+
+    @staticmethod
+    def builder() -> "DataSourceInfoBuilder":
+        return DataSourceInfoBuilder()
+
+
+class DataSourceInfoBuilder:
+    """Builder for DataSourceInfo."""
+
+    def __init__(self):
+        self._data_source_info = DataSourceInfo()
+
+    def build(self) -> DataSourceInfo:
+        return self._data_source_info
+
+    def upload_file_id(self, upload_file_id: str) -> "DataSourceInfoBuilder":
+        self._data_source_info.upload_file_id = upload_file_id
+        return self
+
+    def original_document_id(self, original_document_id: str) -> "DataSourceInfoBuilder":
+        self._data_source_info.original_document_id = original_document_id
+        return self

dify_oapi/api/knowledge/v1/model/dataset_info.py

@@ -0,0 +1,122 @@
+"""Dataset information model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+from .document_metadata import DocumentMetadata
+from .external_knowledge_info import ExternalKnowledgeInfo
+from .knowledge_types import DataSourceType, IndexingTechnique, Permission
+from .retrieval_model import RetrievalModel
+from .tag_info import TagInfo
+
+
+class DatasetInfo(BaseModel):
+    """Dataset information model with builder pattern."""
+
+    id: Optional[str] = None
+    name: Optional[str] = None
+    description: Optional[str] = None
+    provider: Optional[str] = None
+    permission: Optional[Permission] = None
+    data_source_type: Optional[DataSourceType] = None
+    indexing_technique: Optional[IndexingTechnique] = None
+    app_count: Optional[int] = None
+    document_count: Optional[int] = None
+    word_count: Optional[int] = None
+    created_by: Optional[str] = None
+    created_at: Optional[float] = None
+    updated_by: Optional[str] = None
+    updated_at: Optional[float] = None
+    embedding_model: Optional[str] = None
+    embedding_model_provider: Optional[str] = None
+    embedding_available: Optional[bool] = None
+    retrieval_model_dict: Optional[RetrievalModel] = None
+    tags: Optional[list[TagInfo]] = None
+    doc_form: Optional[str] = None
+    external_knowledge_info: Optional[ExternalKnowledgeInfo] = None
+    external_retrieval_model: Optional[RetrievalModel] = None
+    doc_metadata: Optional[list[DocumentMetadata]] = None
+    built_in_field_enabled: Optional[bool] = None
+
+    @staticmethod
+    def builder() -> "DatasetInfoBuilder":
+        return DatasetInfoBuilder()
+
+
+class DatasetInfoBuilder:
+    """Builder for DatasetInfo."""
+
+    def __init__(self):
+        self._dataset_info = DatasetInfo()
+
+    def build(self) -> DatasetInfo:
+        return self._dataset_info
+
+    def id(self, id: str) -> "DatasetInfoBuilder":
+        self._dataset_info.id = id
+        return self
+
+    def name(self, name: str) -> "DatasetInfoBuilder":
+        self._dataset_info.name = name
+        return self
+
+    def description(self, description: str) -> "DatasetInfoBuilder":
+        self._dataset_info.description = description
+        return self
+
+    def indexing_technique(self, indexing_technique: IndexingTechnique) -> "DatasetInfoBuilder":
+        self._dataset_info.indexing_technique = indexing_technique
+        return self
+
+    def permission(self, permission: Permission) -> "DatasetInfoBuilder":
+        self._dataset_info.permission = permission
+        return self
+
+    def data_source_type(self, data_source_type: DataSourceType) -> "DatasetInfoBuilder":
+        self._dataset_info.data_source_type = data_source_type
+        return self
+
+    def provider(self, provider: str) -> "DatasetInfoBuilder":
+        self._dataset_info.provider = provider
+        return self
+
+    def app_count(self, app_count: int) -> "DatasetInfoBuilder":
+        self._dataset_info.app_count = app_count
+        return self
+
+    def created_by(self, created_by: str) -> "DatasetInfoBuilder":
+        self._dataset_info.created_by = created_by
+        return self
+
+    def created_at(self, created_at: float) -> "DatasetInfoBuilder":
+        self._dataset_info.created_at = created_at
+        return self
+
+    def updated_by(self, updated_by: str) -> "DatasetInfoBuilder":
+        self._dataset_info.updated_by = updated_by
+        return self
+
+    def updated_at(self, updated_at: float) -> "DatasetInfoBuilder":
+        self._dataset_info.updated_at = updated_at
+        return self
+
+    def document_count(self, document_count: int) -> "DatasetInfoBuilder":
+        self._dataset_info.document_count = document_count
+        return self
+
+    def word_count(self, word_count: int) -> "DatasetInfoBuilder":
+        self._dataset_info.word_count = word_count
+        return self
+
+    def embedding_model(self, embedding_model: str) -> "DatasetInfoBuilder":
+        self._dataset_info.embedding_model = embedding_model
+        return self
+
+    def embedding_model_provider(self, embedding_model_provider: str) -> "DatasetInfoBuilder":
+        self._dataset_info.embedding_model_provider = embedding_model_provider
+        return self
+
+    def embedding_available(self, embedding_available: bool) -> "DatasetInfoBuilder":
+        self._dataset_info.embedding_available = embedding_available
+        return self

dify_oapi/api/{knowledge_base/v1/model/segment → knowledge/v1/model}/delete_child_chunk_request.py

@@ -1,3 +1,5 @@
+"""Delete child chunk request model."""
+
 from __future__ import annotations
 
 from dify_oapi.core.enum import HttpMethod
@@ -5,7 +7,9 @@ from dify_oapi.core.model.base_request import BaseRequest
 
 
 class DeleteChildChunkRequest(BaseRequest):
-    def __init__(self):
+    """Request model for delete child chunk API."""
+
+    def __init__(self) -> None:
         super().__init__()
         self.dataset_id: str | None = None
         self.document_id: str | None = None
@@ -18,7 +22,9 @@ class DeleteChildChunkRequest(BaseRequest):
 
 
 class DeleteChildChunkRequestBuilder:
-    def __init__(self):
+    """Builder for DeleteChildChunkRequest."""
+
+    def __init__(self) -> None:
         delete_child_chunk_request = DeleteChildChunkRequest()
         delete_child_chunk_request.http_method = HttpMethod.DELETE
         delete_child_chunk_request.uri = (

dify_oapi/api/knowledge/v1/model/delete_child_chunk_response.py

@@ -0,0 +1,9 @@
+"""Delete child chunk response model."""
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class DeleteChildChunkResponse(BaseResponse):
+    """Response model for delete child chunk API."""
+
+    result: str | None = None

dify_oapi/api/knowledge/v1/model/delete_dataset_request.py

@@ -0,0 +1,28 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class DeleteDatasetRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+
+    @staticmethod
+    def builder() -> "DeleteDatasetRequestBuilder":
+        return DeleteDatasetRequestBuilder()
+
+
+class DeleteDatasetRequestBuilder:
+    def __init__(self) -> None:
+        delete_dataset_request = DeleteDatasetRequest()
+        delete_dataset_request.http_method = HttpMethod.DELETE
+        delete_dataset_request.uri = "/v1/datasets/:dataset_id"
+        self._delete_dataset_request = delete_dataset_request
+
+    def build(self) -> DeleteDatasetRequest:
+        return self._delete_dataset_request
+
+    def dataset_id(self, dataset_id: str) -> "DeleteDatasetRequestBuilder":
+        self._delete_dataset_request.dataset_id = dataset_id
+        self._delete_dataset_request.paths["dataset_id"] = dataset_id
+        return self

dify_oapi/api/{knowledge_base/v1/model/tag/delete_response.py → knowledge/v1/model/delete_dataset_response.py}

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

dify_oapi/api/knowledge/v1/model/delete_document_request.py

@@ -0,0 +1,42 @@
+"""Delete document request model."""
+
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class DeleteDocumentRequest(BaseRequest):
+    """Request model for delete document API."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.document_id: str | None = None
+
+    @staticmethod
+    def builder() -> DeleteDocumentRequestBuilder:
+        return DeleteDocumentRequestBuilder()
+
+
+class DeleteDocumentRequestBuilder:
+    """Builder for DeleteDocumentRequest."""
+
+    def __init__(self) -> None:
+        delete_document_request = DeleteDocumentRequest()
+        delete_document_request.http_method = HttpMethod.DELETE
+        delete_document_request.uri = "/v1/datasets/:dataset_id/documents/:document_id"
+        self._delete_document_request = delete_document_request
+
+    def build(self) -> DeleteDocumentRequest:
+        return self._delete_document_request
+
+    def dataset_id(self, dataset_id: str) -> DeleteDocumentRequestBuilder:
+        self._delete_document_request.dataset_id = dataset_id
+        self._delete_document_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def document_id(self, document_id: str) -> DeleteDocumentRequestBuilder:
+        self._delete_document_request.document_id = document_id
+        self._delete_document_request.paths["document_id"] = document_id
+        return self

dify_oapi/api/knowledge/v1/model/delete_document_response.py

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

dify_oapi/api/knowledge/v1/model/delete_segment_request.py

@@ -0,0 +1,48 @@
+"""Delete segment request model."""
+
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class DeleteSegmentRequest(BaseRequest):
+    """Request model for delete segment API."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.document_id: str | None = None
+        self.segment_id: str | None = None
+
+    @staticmethod
+    def builder() -> DeleteSegmentRequestBuilder:
+        return DeleteSegmentRequestBuilder()
+
+
+class DeleteSegmentRequestBuilder:
+    """Builder for DeleteSegmentRequest."""
+
+    def __init__(self) -> None:
+        delete_segment_request = DeleteSegmentRequest()
+        delete_segment_request.http_method = HttpMethod.DELETE
+        delete_segment_request.uri = "/v1/datasets/:dataset_id/documents/:document_id/segments/:segment_id"
+        self._delete_segment_request = delete_segment_request
+
+    def build(self) -> DeleteSegmentRequest:
+        return self._delete_segment_request
+
+    def dataset_id(self, dataset_id: str) -> DeleteSegmentRequestBuilder:
+        self._delete_segment_request.dataset_id = dataset_id
+        self._delete_segment_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def document_id(self, document_id: str) -> DeleteSegmentRequestBuilder:
+        self._delete_segment_request.document_id = document_id
+        self._delete_segment_request.paths["document_id"] = document_id
+        return self
+
+    def segment_id(self, segment_id: str) -> DeleteSegmentRequestBuilder:
+        self._delete_segment_request.segment_id = segment_id
+        self._delete_segment_request.paths["segment_id"] = segment_id
+        return self

dify_oapi/api/knowledge/v1/model/delete_segment_response.py

@@ -0,0 +1,9 @@
+"""Delete segment response model."""
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class DeleteSegmentResponse(BaseResponse):
+    """Response model for delete segment API."""
+
+    result: str | None = None

dify_oapi/api/knowledge/v1/model/delete_tag_request.py

@@ -0,0 +1,30 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .delete_tag_request_body import DeleteTagRequestBody
+
+
+class DeleteTagRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.request_body: DeleteTagRequestBody | None = None
+
+    @staticmethod
+    def builder() -> "DeleteTagRequestBuilder":
+        return DeleteTagRequestBuilder()
+
+
+class DeleteTagRequestBuilder:
+    def __init__(self):
+        delete_tag_request = DeleteTagRequest()
+        delete_tag_request.http_method = HttpMethod.DELETE
+        delete_tag_request.uri = "/v1/datasets/tags"
+        self._delete_tag_request = delete_tag_request
+
+    def build(self) -> DeleteTagRequest:
+        return self._delete_tag_request
+
+    def request_body(self, request_body: DeleteTagRequestBody) -> "DeleteTagRequestBuilder":
+        self._delete_tag_request.request_body = request_body
+        self._delete_tag_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

dify_oapi/api/knowledge/v1/model/delete_tag_request_body.py

@@ -0,0 +1,21 @@
+from pydantic import BaseModel
+
+
+class DeleteTagRequestBody(BaseModel):
+    tag_id: str | None = None
+
+    @staticmethod
+    def builder() -> "DeleteTagRequestBodyBuilder":
+        return DeleteTagRequestBodyBuilder()
+
+
+class DeleteTagRequestBodyBuilder:
+    def __init__(self):
+        self._delete_tag_request_body = DeleteTagRequestBody()
+
+    def build(self) -> DeleteTagRequestBody:
+        return self._delete_tag_request_body
+
+    def tag_id(self, tag_id: str) -> "DeleteTagRequestBodyBuilder":
+        self._delete_tag_request_body.tag_id = tag_id
+        return self

dify_oapi/api/{knowledge_base/v1/model/tag/unbind_response.py → knowledge/v1/model/delete_tag_response.py}

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