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

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

@@ -1,164 +0,0 @@
-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/document_types.py

@@ -1,36 +0,0 @@
-from __future__ import annotations
-
-from typing import Literal
-
-# Indexing technique types
-IndexingTechnique = Literal["high_quality", "economy"]
-
-# Document form types
-DocumentForm = Literal["text_model", "hierarchical_model", "qa_model"]
-
-# Document language types
-DocumentLanguage = Literal["English", "Chinese", "Japanese", "Korean"]
-
-# Processing rule mode types
-ProcessingRuleMode = Literal["automatic", "custom"]
-
-# Segmentation separator types
-Separator = Literal["\\n\\n", "\\n", ".", "!", "?", ";"]
-
-# Pre-processing rule types
-PreProcessingRuleType = Literal["remove_extra_spaces", "remove_urls_emails"]
-
-# Data source types
-DataSourceType = Literal["upload_file", "notion_import", "website_crawl"]
-
-# Document indexing status types
-IndexingStatus = Literal["waiting", "parsing", "cleaning", "splitting", "indexing", "completed", "error", "paused"]
-
-# Document status action types
-StatusAction = Literal["enable", "disable", "archive"]
-
-# Upload file status types
-UploadFileStatus = Literal["success", "processing", "error"]
-
-# Document enabled status
-DocumentEnabled = Literal[True, False]

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

@@ -1,40 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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/pre_processing_rule.py

@@ -1,32 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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