dify-oapi2 0.1.0__py3-none-any.whl

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

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel
+
+from .data_source_info import DataSourceInfo
+
+
+class DocumentInfo(BaseModel):
+    """Document information model containing all document-related fields."""
+
+    id: str | None = None
+    position: int | None = None
+    data_source_type: str | None = None
+    data_source_info: DataSourceInfo | None = None
+    dataset_process_rule_id: str | None = None
+    name: str | None = None
+    created_from: str | None = None
+    created_by: str | None = None
+    created_at: int | None = None
+    tokens: int | None = None
+    indexing_status: str | None = None
+    error: str | None = None
+    enabled: bool | None = None
+    disabled_at: int | None = None
+    disabled_by: str | None = None
+    archived: bool | None = None
+    display_status: str | None = None
+    word_count: int | None = None
+    hit_count: int | None = None
+    doc_form: str | None = None
+    doc_language: str | None = None
+    completed_at: int | None = None
+    updated_at: int | None = None
+    indexing_latency: float | None = None
+    segment_count: int | None = None
+    average_segment_length: int | None = None
+    dataset_process_rule: dict | None = None
+    document_process_rule: dict | None = None
+
+    @staticmethod
+    def builder() -> DocumentInfoBuilder:
+        return DocumentInfoBuilder()
+
+
+class DocumentInfoBuilder:
+    def __init__(self):
+        self._document_info = DocumentInfo()
+
+    def build(self) -> DocumentInfo:
+        return self._document_info
+
+    def id(self, id: str) -> DocumentInfoBuilder:
+        self._document_info.id = id
+        return self
+
+    def position(self, position: int) -> DocumentInfoBuilder:
+        self._document_info.position = position
+        return self
+
+    def data_source_type(self, data_source_type: str) -> DocumentInfoBuilder:
+        self._document_info.data_source_type = data_source_type
+        return self
+
+    def data_source_info(self, data_source_info: DataSourceInfo) -> DocumentInfoBuilder:
+        self._document_info.data_source_info = data_source_info
+        return self
+
+    def dataset_process_rule_id(self, dataset_process_rule_id: str) -> DocumentInfoBuilder:
+        self._document_info.dataset_process_rule_id = dataset_process_rule_id
+        return self
+
+    def name(self, name: str) -> DocumentInfoBuilder:
+        self._document_info.name = name
+        return self
+
+    def created_from(self, created_from: str) -> DocumentInfoBuilder:
+        self._document_info.created_from = created_from
+        return self
+
+    def created_by(self, created_by: str) -> DocumentInfoBuilder:
+        self._document_info.created_by = created_by
+        return self
+
+    def created_at(self, created_at: int) -> DocumentInfoBuilder:
+        self._document_info.created_at = created_at
+        return self
+
+    def tokens(self, tokens: int) -> DocumentInfoBuilder:
+        self._document_info.tokens = tokens
+        return self
+
+    def indexing_status(self, indexing_status: str) -> DocumentInfoBuilder:
+        self._document_info.indexing_status = indexing_status
+        return self
+
+    def error(self, error: str) -> DocumentInfoBuilder:
+        self._document_info.error = error
+        return self
+
+    def enabled(self, enabled: bool) -> DocumentInfoBuilder:
+        self._document_info.enabled = enabled
+        return self
+
+    def disabled_at(self, disabled_at: int) -> DocumentInfoBuilder:
+        self._document_info.disabled_at = disabled_at
+        return self
+
+    def disabled_by(self, disabled_by: str) -> DocumentInfoBuilder:
+        self._document_info.disabled_by = disabled_by
+        return self
+
+    def archived(self, archived: bool) -> DocumentInfoBuilder:
+        self._document_info.archived = archived
+        return self
+
+    def display_status(self, display_status: str) -> DocumentInfoBuilder:
+        self._document_info.display_status = display_status
+        return self
+
+    def word_count(self, word_count: int) -> DocumentInfoBuilder:
+        self._document_info.word_count = word_count
+        return self
+
+    def hit_count(self, hit_count: int) -> DocumentInfoBuilder:
+        self._document_info.hit_count = hit_count
+        return self
+
+    def doc_form(self, doc_form: Literal["text_model", "hierarchical_model", "qa_model"]) -> DocumentInfoBuilder:
+        self._document_info.doc_form = doc_form
+        return self
+
+    def doc_language(self, doc_language: str) -> DocumentInfoBuilder:
+        self._document_info.doc_language = doc_language
+        return self
+
+    def completed_at(self, completed_at: int) -> DocumentInfoBuilder:
+        self._document_info.completed_at = completed_at
+        return self
+
+    def updated_at(self, updated_at: int) -> DocumentInfoBuilder:
+        self._document_info.updated_at = updated_at
+        return self
+
+    def indexing_latency(self, indexing_latency: float) -> DocumentInfoBuilder:
+        self._document_info.indexing_latency = indexing_latency
+        return self
+
+    def segment_count(self, segment_count: int) -> DocumentInfoBuilder:
+        self._document_info.segment_count = segment_count
+        return self
+
+    def average_segment_length(self, average_segment_length: int) -> DocumentInfoBuilder:
+        self._document_info.average_segment_length = average_segment_length
+        return self
+
+    def dataset_process_rule(self, dataset_process_rule: dict) -> DocumentInfoBuilder:
+        self._document_info.dataset_process_rule = dataset_process_rule
+        return self
+
+    def document_process_rule(self, document_process_rule: dict) -> DocumentInfoBuilder:
+        self._document_info.document_process_rule = document_process_rule
+        return self

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

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class GetRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.document_id: str | None = None
+
+    @staticmethod
+    def builder() -> GetRequestBuilder:
+        return GetRequestBuilder()
+
+
+class GetRequestBuilder:
+    def __init__(self):
+        get_request = GetRequest()
+        get_request.http_method = HttpMethod.GET
+        get_request.uri = "/v1/datasets/:dataset_id/documents/:document_id"
+        self._get_request = get_request
+
+    def build(self) -> GetRequest:
+        return self._get_request
+
+    def dataset_id(self, dataset_id: str) -> GetRequestBuilder:
+        self._get_request.dataset_id = dataset_id
+        self._get_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def document_id(self, document_id: str) -> GetRequestBuilder:
+        self._get_request.document_id = document_id
+        self._get_request.paths["document_id"] = document_id
+        return self
+
+    def metadata(self, metadata: str) -> GetRequestBuilder:
+        self._get_request.add_query("metadata", metadata)
+        return self

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

@@ -0,0 +1,9 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .document_info import DocumentInfo
+
+
+class GetResponse(DocumentInfo, BaseResponse):
+    """Response model for get document API"""
+
+    pass

dify_oapi/api/knowledge_base/v1/model/document/get_upload_file_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
+
+
+class GetUploadFileRequest(BaseRequest):
+    """Request model for get upload file API."""
+
+    def __init__(self):
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.document_id: str | None = None
+
+    @staticmethod
+    def builder() -> GetUploadFileRequestBuilder:
+        return GetUploadFileRequestBuilder()
+
+
+class GetUploadFileRequestBuilder:
+    def __init__(self):
+        get_upload_file_request = GetUploadFileRequest()
+        get_upload_file_request.http_method = HttpMethod.GET
+        get_upload_file_request.uri = "/v1/datasets/:dataset_id/documents/:document_id/upload-file"
+        self._get_upload_file_request = get_upload_file_request
+
+    def build(self) -> GetUploadFileRequest:
+        return self._get_upload_file_request
+
+    def dataset_id(self, dataset_id: str) -> GetUploadFileRequestBuilder:
+        self._get_upload_file_request.dataset_id = dataset_id
+        self._get_upload_file_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def document_id(self, document_id: str) -> GetUploadFileRequestBuilder:
+        self._get_upload_file_request.document_id = document_id
+        self._get_upload_file_request.paths["document_id"] = document_id
+        return self

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

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .upload_file_info import UploadFileInfo
+
+
+class GetUploadFileResponse(UploadFileInfo, BaseResponse):
+    """Response model for get upload file API."""
+
+    pass

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

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class IndexingStatusInfo(BaseModel):
+    """Indexing status information model for document processing status."""
+
+    id: str | None = None
+    indexing_status: str | None = None
+    processing_started_at: float | None = None
+    parsing_completed_at: float | None = None
+    cleaning_completed_at: float | None = None
+    splitting_completed_at: float | None = None
+    completed_at: float | None = None
+    paused_at: float | None = None
+    error: str | None = None
+    stopped_at: float | None = None
+    completed_segments: int | None = None
+    total_segments: int | None = None
+
+    @staticmethod
+    def builder() -> IndexingStatusInfoBuilder:
+        return IndexingStatusInfoBuilder()
+
+
+class IndexingStatusInfoBuilder:
+    def __init__(self):
+        self._indexing_status_info = IndexingStatusInfo()
+
+    def build(self) -> IndexingStatusInfo:
+        return self._indexing_status_info
+
+    def id(self, id: str) -> IndexingStatusInfoBuilder:
+        self._indexing_status_info.id = id
+        return self
+
+    def indexing_status(self, indexing_status: str) -> IndexingStatusInfoBuilder:
+        self._indexing_status_info.indexing_status = indexing_status
+        return self
+
+    def processing_started_at(self, processing_started_at: float) -> IndexingStatusInfoBuilder:
+        self._indexing_status_info.processing_started_at = processing_started_at
+        return self
+
+    def parsing_completed_at(self, parsing_completed_at: float) -> IndexingStatusInfoBuilder:
+        self._indexing_status_info.parsing_completed_at = parsing_completed_at
+        return self
+
+    def cleaning_completed_at(self, cleaning_completed_at: float) -> IndexingStatusInfoBuilder:
+        self._indexing_status_info.cleaning_completed_at = cleaning_completed_at
+        return self
+
+    def splitting_completed_at(self, splitting_completed_at: float) -> IndexingStatusInfoBuilder:
+        self._indexing_status_info.splitting_completed_at = splitting_completed_at
+        return self
+
+    def completed_at(self, completed_at: float) -> IndexingStatusInfoBuilder:
+        self._indexing_status_info.completed_at = completed_at
+        return self
+
+    def paused_at(self, paused_at: float) -> IndexingStatusInfoBuilder:
+        self._indexing_status_info.paused_at = paused_at
+        return self
+
+    def error(self, error: str) -> IndexingStatusInfoBuilder:
+        self._indexing_status_info.error = error
+        return self
+
+    def stopped_at(self, stopped_at: float) -> IndexingStatusInfoBuilder:
+        self._indexing_status_info.stopped_at = stopped_at
+        return self
+
+    def completed_segments(self, completed_segments: int) -> IndexingStatusInfoBuilder:
+        self._indexing_status_info.completed_segments = completed_segments
+        return self
+
+    def total_segments(self, total_segments: int) -> IndexingStatusInfoBuilder:
+        self._indexing_status_info.total_segments = total_segments
+        return self

dify_oapi/api/knowledge_base/v1/model/document/indexing_status_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 IndexingStatusRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.batch: str | None = None
+
+    @staticmethod
+    def builder() -> IndexingStatusRequestBuilder:
+        return IndexingStatusRequestBuilder()
+
+
+class IndexingStatusRequestBuilder:
+    def __init__(self):
+        indexing_status_request = IndexingStatusRequest()
+        indexing_status_request.http_method = HttpMethod.GET
+        indexing_status_request.uri = "/v1/datasets/:dataset_id/documents/:batch/indexing-status"
+        self._indexing_status_request = indexing_status_request
+
+    def build(self) -> IndexingStatusRequest:
+        return self._indexing_status_request
+
+    def dataset_id(self, dataset_id: str) -> IndexingStatusRequestBuilder:
+        self._indexing_status_request.dataset_id = dataset_id
+        self._indexing_status_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def batch(self, batch: str) -> IndexingStatusRequestBuilder:
+        self._indexing_status_request.batch = batch
+        self._indexing_status_request.paths["batch"] = batch
+        return self

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

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .indexing_status_info import IndexingStatusInfo
+
+
+class IndexingStatusResponse(BaseResponse):
+    """Response model for indexing status API"""
+
+    data: list[IndexingStatusInfo] | None = None

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

@@ -0,0 +1,42 @@
+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/documents"
+        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
+
+    def keyword(self, keyword: str) -> ListRequestBuilder:
+        self._list_request.add_query("keyword", keyword)
+        return self
+
+    def page(self, page: int) -> ListRequestBuilder:
+        self._list_request.add_query("page", page)
+        return self
+
+    def limit(self, limit: int) -> ListRequestBuilder:
+        self._list_request.add_query("limit", limit)
+        return self

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

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .document_info import DocumentInfo
+
+
+class ListResponse(BaseResponse):
+    """Response model for list documents API"""
+
+    data: list[DocumentInfo] | None = None
+    has_more: bool | None = None
+    limit: int | None = None
+    total: int | None = None
+    page: int | None = None

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

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel
+
+
+class PreProcessingRule(BaseModel):
+    """Pre-processing rule model for document preprocessing configuration."""
+
+    id: str | None = None
+    enabled: bool | None = None
+
+    @staticmethod
+    def builder() -> PreProcessingRuleBuilder:
+        return PreProcessingRuleBuilder()
+
+
+class PreProcessingRuleBuilder:
+    def __init__(self):
+        self._pre_processing_rule = PreProcessingRule()
+
+    def build(self) -> PreProcessingRule:
+        return self._pre_processing_rule
+
+    def id(self, id: Literal["remove_extra_spaces", "remove_urls_emails"]) -> PreProcessingRuleBuilder:
+        self._pre_processing_rule.id = id
+        return self
+
+    def enabled(self, enabled: bool) -> PreProcessingRuleBuilder:
+        self._pre_processing_rule.enabled = enabled
+        return self

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

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel
+
+from .rules import Rules
+
+
+class ProcessRule(BaseModel):
+    """Processing rule model for document processing configuration."""
+
+    mode: str | None = None
+    rules: Rules | None = None
+
+    @staticmethod
+    def builder() -> ProcessRuleBuilder:
+        return ProcessRuleBuilder()
+
+
+class ProcessRuleBuilder:
+    def __init__(self):
+        self._process_rule = ProcessRule()
+
+    def build(self) -> ProcessRule:
+        return self._process_rule
+
+    def mode(self, mode: Literal["automatic", "custom"]) -> ProcessRuleBuilder:
+        self._process_rule.mode = mode
+        return self
+
+    def rules(self, rules: Rules) -> ProcessRuleBuilder:
+        self._process_rule.rules = rules
+        return self

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

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel
+
+
+class RetrievalModel(BaseModel):
+    """Document-specific retrieval model for search and retrieval configuration."""
+
+    search_method: str | None = None
+    reranking_enable: bool | None = None
+    reranking_model: dict | None = None
+    top_k: int | None = None
+    score_threshold_enabled: bool | None = None
+    score_threshold: float | None = None
+
+    @staticmethod
+    def builder() -> RetrievalModelBuilder:
+        return RetrievalModelBuilder()
+
+
+class RetrievalModelBuilder:
+    def __init__(self):
+        self._retrieval_model = RetrievalModel()
+
+    def build(self) -> RetrievalModel:
+        return self._retrieval_model
+
+    def search_method(
+        self, search_method: Literal["keyword_search", "semantic_search", "full_text_search", "hybrid_search"]
+    ) -> RetrievalModelBuilder:
+        self._retrieval_model.search_method = search_method
+        return self
+
+    def reranking_enable(self, reranking_enable: bool) -> RetrievalModelBuilder:
+        self._retrieval_model.reranking_enable = reranking_enable
+        return self
+
+    def reranking_model(self, reranking_model: dict) -> RetrievalModelBuilder:
+        self._retrieval_model.reranking_model = reranking_model
+        return self
+
+    def top_k(self, top_k: int) -> RetrievalModelBuilder:
+        self._retrieval_model.top_k = top_k
+        return self
+
+    def score_threshold_enabled(self, score_threshold_enabled: bool) -> RetrievalModelBuilder:
+        self._retrieval_model.score_threshold_enabled = score_threshold_enabled
+        return self
+
+    def score_threshold(self, score_threshold: float) -> RetrievalModelBuilder:
+        self._retrieval_model.score_threshold = score_threshold
+        return self

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

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .pre_processing_rule import PreProcessingRule
+from .segmentation import Segmentation
+
+
+class Rules(BaseModel):
+    pre_processing_rules: list[PreProcessingRule] | None = None
+    segmentation: Segmentation | None = None
+
+    @staticmethod
+    def builder() -> RulesBuilder:
+        return RulesBuilder()
+
+
+class RulesBuilder:
+    def __init__(self):
+        self._rules = Rules()
+
+    def build(self) -> Rules:
+        return self._rules
+
+    def pre_processing_rules(self, pre_processing_rules: list[PreProcessingRule]) -> RulesBuilder:
+        self._rules.pre_processing_rules = pre_processing_rules
+        return self
+
+    def segmentation(self, segmentation: Segmentation) -> RulesBuilder:
+        self._rules.segmentation = segmentation
+        return self

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

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class Segmentation(BaseModel):
+    """Segmentation rule model for document text segmentation configuration."""
+
+    separator: str | None = None
+    max_tokens: int | None = None
+    chunk_overlap: int | None = None
+
+    @staticmethod
+    def builder() -> SegmentationBuilder:
+        return SegmentationBuilder()
+
+
+class SegmentationBuilder:
+    def __init__(self):
+        self._segmentation = Segmentation()
+
+    def build(self) -> Segmentation:
+        return self._segmentation
+
+    def separator(self, separator: str) -> SegmentationBuilder:
+        self._segmentation.separator = separator
+        return self
+
+    def max_tokens(self, max_tokens: int) -> SegmentationBuilder:
+        self._segmentation.max_tokens = max_tokens
+        return self
+
+    def chunk_overlap(self, chunk_overlap: int) -> SegmentationBuilder:
+        self._segmentation.chunk_overlap = chunk_overlap
+        return self

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

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class SubchunkSegmentation(BaseModel):
+    """Sub-chunk segmentation rule model for hierarchical document segmentation."""
+
+    separator: str | None = None
+    max_tokens: int | None = None
+    chunk_overlap: int | None = None
+
+    @staticmethod
+    def builder() -> SubchunkSegmentationBuilder:
+        return SubchunkSegmentationBuilder()
+
+
+class SubchunkSegmentationBuilder:
+    def __init__(self):
+        self._subchunk_segmentation = SubchunkSegmentation()
+
+    def build(self) -> SubchunkSegmentation:
+        return self._subchunk_segmentation
+
+    def separator(self, separator: str) -> SubchunkSegmentationBuilder:
+        self._subchunk_segmentation.separator = separator
+        return self
+
+    def max_tokens(self, max_tokens: int) -> SubchunkSegmentationBuilder:
+        self._subchunk_segmentation.max_tokens = max_tokens
+        return self
+
+    def chunk_overlap(self, chunk_overlap: int) -> SubchunkSegmentationBuilder:
+        self._subchunk_segmentation.chunk_overlap = chunk_overlap
+        return self