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

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

@@ -0,0 +1,39 @@
+"""Segment content model for Knowledge Base API."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class SegmentContent(BaseModel):
+    """Segment content model with builder pattern."""
+
+    content: str | None = None
+    answer: str | None = None
+    keywords: list[str] | None = None
+
+    @staticmethod
+    def builder() -> SegmentContentBuilder:
+        return SegmentContentBuilder()
+
+
+class SegmentContentBuilder:
+    """Builder for SegmentContent."""
+
+    def __init__(self) -> None:
+        self._segment_content = SegmentContent()
+
+    def build(self) -> SegmentContent:
+        return self._segment_content
+
+    def content(self, content: str) -> SegmentContentBuilder:
+        self._segment_content.content = content
+        return self
+
+    def answer(self, answer: str) -> SegmentContentBuilder:
+        self._segment_content.answer = answer
+        return self
+
+    def keywords(self, keywords: list[str]) -> SegmentContentBuilder:
+        self._segment_content.keywords = keywords
+        return self

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

@@ -0,0 +1,41 @@
+"""Segment document information model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+from .knowledge_types import DataSourceType
+
+
+class SegmentDocumentInfo(BaseModel):
+    """Segment document information model with builder pattern."""
+
+    id: Optional[str] = None
+    data_source_type: Optional[DataSourceType] = None
+    name: Optional[str] = None
+
+    @staticmethod
+    def builder() -> "SegmentDocumentInfoBuilder":
+        return SegmentDocumentInfoBuilder()
+
+
+class SegmentDocumentInfoBuilder:
+    """Builder for SegmentDocumentInfo."""
+
+    def __init__(self):
+        self._segment_document_info = SegmentDocumentInfo()
+
+    def build(self) -> SegmentDocumentInfo:
+        return self._segment_document_info
+
+    def id(self, id: str) -> "SegmentDocumentInfoBuilder":
+        self._segment_document_info.id = id
+        return self
+
+    def data_source_type(self, data_source_type: DataSourceType) -> "SegmentDocumentInfoBuilder":
+        self._segment_document_info.data_source_type = data_source_type
+        return self
+
+    def name(self, name: str) -> "SegmentDocumentInfoBuilder":
+        self._segment_document_info.name = name
+        return self

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

@@ -0,0 +1,131 @@
+"""Segment information model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+from .knowledge_types import SegmentStatus
+
+
+class SegmentInfo(BaseModel):
+    """Segment information model with builder pattern."""
+
+    id: Optional[str] = None
+    position: Optional[int] = None
+    document_id: Optional[str] = None
+    content: Optional[str] = None
+    answer: Optional[str] = None
+    word_count: Optional[int] = None
+    tokens: Optional[int] = None
+    keywords: Optional[list[str]] = None
+    index_node_id: Optional[str] = None
+    index_node_hash: Optional[str] = None
+    hit_count: Optional[int] = None
+    enabled: Optional[bool] = None
+    disabled_at: Optional[float] = None
+    disabled_by: Optional[str] = None
+    status: Optional[SegmentStatus] = None
+    created_by: Optional[str] = None
+    created_at: Optional[float] = None
+    indexing_at: Optional[float] = None
+    completed_at: Optional[float] = None
+    error: Optional[str] = None
+    stopped_at: Optional[float] = None
+
+    @staticmethod
+    def builder() -> "SegmentInfoBuilder":
+        return SegmentInfoBuilder()
+
+
+class SegmentInfoBuilder:
+    """Builder for SegmentInfo."""
+
+    def __init__(self):
+        self._segment_info = SegmentInfo()
+
+    def build(self) -> SegmentInfo:
+        return self._segment_info
+
+    def id(self, id: str) -> "SegmentInfoBuilder":
+        self._segment_info.id = id
+        return self
+
+    def position(self, position: int) -> "SegmentInfoBuilder":
+        self._segment_info.position = position
+        return self
+
+    def document_id(self, document_id: str) -> "SegmentInfoBuilder":
+        self._segment_info.document_id = document_id
+        return self
+
+    def content(self, content: str) -> "SegmentInfoBuilder":
+        self._segment_info.content = content
+        return self
+
+    def answer(self, answer: str) -> "SegmentInfoBuilder":
+        self._segment_info.answer = answer
+        return self
+
+    def word_count(self, word_count: int) -> "SegmentInfoBuilder":
+        self._segment_info.word_count = word_count
+        return self
+
+    def tokens(self, tokens: int) -> "SegmentInfoBuilder":
+        self._segment_info.tokens = tokens
+        return self
+
+    def keywords(self, keywords: list[str]) -> "SegmentInfoBuilder":
+        self._segment_info.keywords = keywords
+        return self
+
+    def index_node_id(self, index_node_id: str) -> "SegmentInfoBuilder":
+        self._segment_info.index_node_id = index_node_id
+        return self
+
+    def index_node_hash(self, index_node_hash: str) -> "SegmentInfoBuilder":
+        self._segment_info.index_node_hash = index_node_hash
+        return self
+
+    def hit_count(self, hit_count: int) -> "SegmentInfoBuilder":
+        self._segment_info.hit_count = hit_count
+        return self
+
+    def enabled(self, enabled: bool) -> "SegmentInfoBuilder":
+        self._segment_info.enabled = enabled
+        return self
+
+    def disabled_at(self, disabled_at: float) -> "SegmentInfoBuilder":
+        self._segment_info.disabled_at = disabled_at
+        return self
+
+    def disabled_by(self, disabled_by: str) -> "SegmentInfoBuilder":
+        self._segment_info.disabled_by = disabled_by
+        return self
+
+    def status(self, status: SegmentStatus) -> "SegmentInfoBuilder":
+        self._segment_info.status = status
+        return self
+
+    def created_by(self, created_by: str) -> "SegmentInfoBuilder":
+        self._segment_info.created_by = created_by
+        return self
+
+    def created_at(self, created_at: float) -> "SegmentInfoBuilder":
+        self._segment_info.created_at = created_at
+        return self
+
+    def indexing_at(self, indexing_at: float) -> "SegmentInfoBuilder":
+        self._segment_info.indexing_at = indexing_at
+        return self
+
+    def completed_at(self, completed_at: float) -> "SegmentInfoBuilder":
+        self._segment_info.completed_at = completed_at
+        return self
+
+    def error(self, error: str) -> "SegmentInfoBuilder":
+        self._segment_info.error = error
+        return self
+
+    def stopped_at(self, stopped_at: float) -> "SegmentInfoBuilder":
+        self._segment_info.stopped_at = stopped_at
+        return self

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

@@ -0,0 +1,44 @@
+"""Segmentation rule model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class SegmentationRule(BaseModel):
+    """Segmentation rule model with builder pattern."""
+
+    separator: Optional[str] = None
+    max_tokens: Optional[int] = None
+    chunk_overlap: Optional[int] = None
+    rules: Optional[dict] = None
+
+    @staticmethod
+    def builder() -> "SegmentationRuleBuilder":
+        return SegmentationRuleBuilder()
+
+
+class SegmentationRuleBuilder:
+    """Builder for SegmentationRule."""
+
+    def __init__(self):
+        self._segmentation_rule = SegmentationRule()
+
+    def build(self) -> SegmentationRule:
+        return self._segmentation_rule
+
+    def separator(self, separator: str) -> "SegmentationRuleBuilder":
+        self._segmentation_rule.separator = separator
+        return self
+
+    def max_tokens(self, max_tokens: int) -> "SegmentationRuleBuilder":
+        self._segmentation_rule.max_tokens = max_tokens
+        return self
+
+    def chunk_overlap(self, chunk_overlap: int) -> "SegmentationRuleBuilder":
+        self._segmentation_rule.chunk_overlap = chunk_overlap
+        return self
+
+    def rules(self, rules: dict) -> "SegmentationRuleBuilder":
+        self._segmentation_rule.rules = rules
+        return self

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

@@ -0,0 +1,39 @@
+"""Sub-chunk segmentation rule model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class SubChunkSegmentationRule(BaseModel):
+    """Sub-chunk segmentation rule model with builder pattern."""
+
+    separator: Optional[str] = None
+    max_tokens: Optional[int] = None
+    chunk_overlap: Optional[int] = None
+
+    @staticmethod
+    def builder() -> "SubChunkSegmentationRuleBuilder":
+        return SubChunkSegmentationRuleBuilder()
+
+
+class SubChunkSegmentationRuleBuilder:
+    """Builder for SubChunkSegmentationRule."""
+
+    def __init__(self):
+        self._subchunk_segmentation_rule = SubChunkSegmentationRule()
+
+    def build(self) -> SubChunkSegmentationRule:
+        return self._subchunk_segmentation_rule
+
+    def separator(self, separator: str) -> "SubChunkSegmentationRuleBuilder":
+        self._subchunk_segmentation_rule.separator = separator
+        return self
+
+    def max_tokens(self, max_tokens: int) -> "SubChunkSegmentationRuleBuilder":
+        self._subchunk_segmentation_rule.max_tokens = max_tokens
+        return self
+
+    def chunk_overlap(self, chunk_overlap: int) -> "SubChunkSegmentationRuleBuilder":
+        self._subchunk_segmentation_rule.chunk_overlap = chunk_overlap
+        return self

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

@@ -0,0 +1,56 @@
+"""Tag information model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+from .knowledge_types import TagType
+
+
+class TagInfo(BaseModel):
+    """Tag information model with builder pattern."""
+
+    id: Optional[str] = None
+    name: Optional[str] = None
+    type: Optional[TagType] = None
+    binding_count: Optional[int] = None
+    created_by: Optional[str] = None
+    created_at: Optional[float] = None
+
+    @staticmethod
+    def builder() -> "TagInfoBuilder":
+        return TagInfoBuilder()
+
+
+class TagInfoBuilder:
+    """Builder for TagInfo."""
+
+    def __init__(self):
+        self._tag_info = TagInfo()
+
+    def build(self) -> TagInfo:
+        return self._tag_info
+
+    def id(self, id: str) -> "TagInfoBuilder":
+        self._tag_info.id = id
+        return self
+
+    def name(self, name: str) -> "TagInfoBuilder":
+        self._tag_info.name = name
+        return self
+
+    def type(self, type: TagType) -> "TagInfoBuilder":
+        self._tag_info.type = type
+        return self
+
+    def created_by(self, created_by: str) -> "TagInfoBuilder":
+        self._tag_info.created_by = created_by
+        return self
+
+    def created_at(self, created_at: float) -> "TagInfoBuilder":
+        self._tag_info.created_at = created_at
+        return self
+
+    def binding_count(self, binding_count: int) -> "TagInfoBuilder":
+        self._tag_info.binding_count = binding_count
+        return self

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

@@ -0,0 +1,30 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .unbind_tags_from_dataset_request_body import UnbindTagsFromDatasetRequestBody
+
+
+class UnbindTagsFromDatasetRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.request_body: UnbindTagsFromDatasetRequestBody | None = None
+
+    @staticmethod
+    def builder() -> "UnbindTagsFromDatasetRequestBuilder":
+        return UnbindTagsFromDatasetRequestBuilder()
+
+
+class UnbindTagsFromDatasetRequestBuilder:
+    def __init__(self):
+        unbind_tags_from_dataset_request = UnbindTagsFromDatasetRequest()
+        unbind_tags_from_dataset_request.http_method = HttpMethod.POST
+        unbind_tags_from_dataset_request.uri = "/v1/datasets/tags/unbinding"
+        self._unbind_tags_from_dataset_request = unbind_tags_from_dataset_request
+
+    def build(self) -> UnbindTagsFromDatasetRequest:
+        return self._unbind_tags_from_dataset_request
+
+    def request_body(self, request_body: UnbindTagsFromDatasetRequestBody) -> "UnbindTagsFromDatasetRequestBuilder":
+        self._unbind_tags_from_dataset_request.request_body = request_body
+        self._unbind_tags_from_dataset_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

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

@@ -0,0 +1,26 @@
+from pydantic import BaseModel
+
+
+class UnbindTagsFromDatasetRequestBody(BaseModel):
+    target_id: str | None = None
+    tag_id: str | None = None
+
+    @staticmethod
+    def builder() -> "UnbindTagsFromDatasetRequestBodyBuilder":
+        return UnbindTagsFromDatasetRequestBodyBuilder()
+
+
+class UnbindTagsFromDatasetRequestBodyBuilder:
+    def __init__(self):
+        self._unbind_tags_from_dataset_request_body = UnbindTagsFromDatasetRequestBody()
+
+    def build(self) -> UnbindTagsFromDatasetRequestBody:
+        return self._unbind_tags_from_dataset_request_body
+
+    def target_id(self, target_id: str) -> "UnbindTagsFromDatasetRequestBodyBuilder":
+        self._unbind_tags_from_dataset_request_body.target_id = target_id
+        return self
+
+    def tag_id(self, tag_id: str) -> "UnbindTagsFromDatasetRequestBodyBuilder":
+        self._unbind_tags_from_dataset_request_body.tag_id = tag_id
+        return self

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

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

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

@@ -1,3 +1,5 @@
+"""Update child chunk request model."""
+
 from __future__ import annotations
 
 from dify_oapi.core.enum import HttpMethod
@@ -7,7 +9,9 @@ from .update_child_chunk_request_body import UpdateChildChunkRequestBody
 
 
 class UpdateChildChunkRequest(BaseRequest):
-    def __init__(self):
+    """Request model for update child chunk API."""
+
+    def __init__(self) -> None:
         super().__init__()
         self.dataset_id: str | None = None
         self.document_id: str | None = None
@@ -21,7 +25,9 @@ class UpdateChildChunkRequest(BaseRequest):
 
 
 class UpdateChildChunkRequestBuilder:
-    def __init__(self):
+    """Builder for UpdateChildChunkRequest."""
+
+    def __init__(self) -> None:
         update_child_chunk_request = UpdateChildChunkRequest()
         update_child_chunk_request.http_method = HttpMethod.PATCH
         update_child_chunk_request.uri = (

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

@@ -1,10 +1,15 @@
+"""Update child chunk request body model."""
+
 from __future__ import annotations
 
 from pydantic import BaseModel
 
 
 class UpdateChildChunkRequestBody(BaseModel):
+    """Request body model for update child chunk API."""
+
     content: str | None = None
+    keywords: list[str] | None = None
 
     @staticmethod
     def builder() -> UpdateChildChunkRequestBodyBuilder:
@@ -12,7 +17,9 @@ class UpdateChildChunkRequestBody(BaseModel):
 
 
 class UpdateChildChunkRequestBodyBuilder:
-    def __init__(self):
+    """Builder for UpdateChildChunkRequestBody."""
+
+    def __init__(self) -> None:
         self._update_child_chunk_request_body = UpdateChildChunkRequestBody()
 
     def build(self) -> UpdateChildChunkRequestBody:
@@ -21,3 +28,7 @@ class UpdateChildChunkRequestBodyBuilder:
     def content(self, content: str) -> UpdateChildChunkRequestBodyBuilder:
         self._update_child_chunk_request_body.content = content
         return self
+
+    def keywords(self, keywords: list[str]) -> UpdateChildChunkRequestBodyBuilder:
+        self._update_child_chunk_request_body.keywords = keywords
+        return self

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

@@ -1,7 +1,11 @@
+"""Update child chunk response model."""
+
 from dify_oapi.core.model.base_response import BaseResponse
 
 from .child_chunk_info import ChildChunkInfo
 
 
 class UpdateChildChunkResponse(BaseResponse):
+    """Response model for update child chunk API."""
+
     data: ChildChunkInfo | None = None

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

@@ -0,0 +1,36 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .update_dataset_request_body import UpdateDatasetRequestBody
+
+
+class UpdateDatasetRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.request_body: UpdateDatasetRequestBody | None = None
+
+    @staticmethod
+    def builder() -> "UpdateDatasetRequestBuilder":
+        return UpdateDatasetRequestBuilder()
+
+
+class UpdateDatasetRequestBuilder:
+    def __init__(self) -> None:
+        update_dataset_request = UpdateDatasetRequest()
+        update_dataset_request.http_method = HttpMethod.PATCH
+        update_dataset_request.uri = "/v1/datasets/:dataset_id"
+        self._update_dataset_request = update_dataset_request
+
+    def build(self) -> UpdateDatasetRequest:
+        return self._update_dataset_request
+
+    def dataset_id(self, dataset_id: str) -> "UpdateDatasetRequestBuilder":
+        self._update_dataset_request.dataset_id = dataset_id
+        self._update_dataset_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def request_body(self, request_body: UpdateDatasetRequestBody) -> "UpdateDatasetRequestBuilder":
+        self._update_dataset_request.request_body = request_body
+        self._update_dataset_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

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

@@ -0,0 +1,62 @@
+from pydantic import BaseModel
+
+from .embedding_model_parameters import EmbeddingModelParameters
+from .knowledge_types import IndexingTechnique, Permission
+from .retrieval_model import RetrievalModel
+
+
+class UpdateDatasetRequestBody(BaseModel):
+    name: str | None = None
+    description: str | None = None
+    indexing_technique: IndexingTechnique | None = None
+    permission: Permission | None = None
+    provider: str | None = None
+    model: str | None = None
+    embedding_model_parameters: EmbeddingModelParameters | None = None
+    retrieval_model: RetrievalModel | None = None
+
+    @staticmethod
+    def builder() -> "UpdateDatasetRequestBodyBuilder":
+        return UpdateDatasetRequestBodyBuilder()
+
+
+class UpdateDatasetRequestBodyBuilder:
+    def __init__(self) -> None:
+        self._update_dataset_request_body = UpdateDatasetRequestBody()
+
+    def build(self) -> UpdateDatasetRequestBody:
+        return self._update_dataset_request_body
+
+    def name(self, name: str) -> "UpdateDatasetRequestBodyBuilder":
+        self._update_dataset_request_body.name = name
+        return self
+
+    def description(self, description: str) -> "UpdateDatasetRequestBodyBuilder":
+        self._update_dataset_request_body.description = description
+        return self
+
+    def indexing_technique(self, indexing_technique: IndexingTechnique) -> "UpdateDatasetRequestBodyBuilder":
+        self._update_dataset_request_body.indexing_technique = indexing_technique
+        return self
+
+    def permission(self, permission: Permission) -> "UpdateDatasetRequestBodyBuilder":
+        self._update_dataset_request_body.permission = permission
+        return self
+
+    def provider(self, provider: str) -> "UpdateDatasetRequestBodyBuilder":
+        self._update_dataset_request_body.provider = provider
+        return self
+
+    def model(self, model: str) -> "UpdateDatasetRequestBodyBuilder":
+        self._update_dataset_request_body.model = model
+        return self
+
+    def embedding_model_parameters(
+        self, embedding_model_parameters: EmbeddingModelParameters
+    ) -> "UpdateDatasetRequestBodyBuilder":
+        self._update_dataset_request_body.embedding_model_parameters = embedding_model_parameters
+        return self
+
+    def retrieval_model(self, retrieval_model: RetrievalModel) -> "UpdateDatasetRequestBodyBuilder":
+        self._update_dataset_request_body.retrieval_model = retrieval_model
+        return self

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

@@ -0,0 +1,7 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .dataset_info import DatasetInfo
+
+
+class UpdateDatasetResponse(DatasetInfo, BaseResponse):
+    pass

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

@@ -0,0 +1,61 @@
+"""Update document by file request model."""
+
+from __future__ import annotations
+
+import json
+from io import BytesIO
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .update_document_by_file_request_body import UpdateDocumentByFileRequestBody
+
+
+class UpdateDocumentByFileRequest(BaseRequest):
+    """Request model for update document by file API."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.document_id: str | None = None
+        self.request_body: UpdateDocumentByFileRequestBody | None = None
+        self.file: BytesIO | None = None
+
+    @staticmethod
+    def builder() -> UpdateDocumentByFileRequestBuilder:
+        return UpdateDocumentByFileRequestBuilder()
+
+
+class UpdateDocumentByFileRequestBuilder:
+    """Builder for UpdateDocumentByFileRequest."""
+
+    def __init__(self) -> None:
+        update_document_by_file_request = UpdateDocumentByFileRequest()
+        update_document_by_file_request.http_method = HttpMethod.POST
+        update_document_by_file_request.uri = "/v1/datasets/:dataset_id/documents/:document_id/update-by-file"
+        self._update_document_by_file_request = update_document_by_file_request
+
+    def build(self) -> UpdateDocumentByFileRequest:
+        return self._update_document_by_file_request
+
+    def dataset_id(self, dataset_id: str) -> UpdateDocumentByFileRequestBuilder:
+        self._update_document_by_file_request.dataset_id = dataset_id
+        self._update_document_by_file_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def document_id(self, document_id: str) -> UpdateDocumentByFileRequestBuilder:
+        self._update_document_by_file_request.document_id = document_id
+        self._update_document_by_file_request.paths["document_id"] = document_id
+        return self
+
+    def request_body(self, request_body: UpdateDocumentByFileRequestBody) -> UpdateDocumentByFileRequestBuilder:
+        self._update_document_by_file_request.request_body = request_body
+        data_dict = request_body.model_dump(exclude_none=True, mode="json")
+        self._update_document_by_file_request.body = {"data": json.dumps(data_dict)}
+        return self
+
+    def file(self, file: BytesIO, file_name: str | None = None) -> UpdateDocumentByFileRequestBuilder:
+        self._update_document_by_file_request.file = file
+        file_name = file_name or "upload"
+        self._update_document_by_file_request.files = {"file": (file_name, file)}
+        return self