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

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

@@ -0,0 +1,49 @@
+"""Process rules model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+from .knowledge_types import ParentMode
+from .preprocessing_rule import PreprocessingRule
+from .segmentation_rule import SegmentationRule
+from .subchunk_segmentation_rule import SubChunkSegmentationRule
+
+
+class ProcessRules(BaseModel):
+    """Process rules model with builder pattern."""
+
+    pre_processing_rules: Optional[list[PreprocessingRule]] = None
+    segmentation: Optional[SegmentationRule] = None
+    parent_mode: Optional[ParentMode] = None
+    subchunk_segmentation: Optional[SubChunkSegmentationRule] = None
+
+    @staticmethod
+    def builder() -> "ProcessRulesBuilder":
+        return ProcessRulesBuilder()
+
+
+class ProcessRulesBuilder:
+    """Builder for ProcessRules."""
+
+    def __init__(self):
+        self._process_rules = ProcessRules()
+
+    def build(self) -> ProcessRules:
+        return self._process_rules
+
+    def pre_processing_rules(self, pre_processing_rules: list[PreprocessingRule]) -> "ProcessRulesBuilder":
+        self._process_rules.pre_processing_rules = pre_processing_rules
+        return self
+
+    def segmentation(self, segmentation: SegmentationRule) -> "ProcessRulesBuilder":
+        self._process_rules.segmentation = segmentation
+        return self
+
+    def parent_mode(self, parent_mode: ParentMode) -> "ProcessRulesBuilder":
+        self._process_rules.parent_mode = parent_mode
+        return self
+
+    def subchunk_segmentation(self, subchunk_segmentation: SubChunkSegmentationRule) -> "ProcessRulesBuilder":
+        self._process_rules.subchunk_segmentation = subchunk_segmentation
+        return self

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

@@ -0,0 +1,29 @@
+"""Query information model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class QueryInfo(BaseModel):
+    """Query information model with builder pattern."""
+
+    content: Optional[str] = None
+
+    @staticmethod
+    def builder() -> "QueryInfoBuilder":
+        return QueryInfoBuilder()
+
+
+class QueryInfoBuilder:
+    """Builder for QueryInfo."""
+
+    def __init__(self):
+        self._query_info = QueryInfo()
+
+    def build(self) -> QueryInfo:
+        return self._query_info
+
+    def content(self, content: str) -> "QueryInfoBuilder":
+        self._query_info.content = content
+        return self

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

@@ -0,0 +1,36 @@
+"""Reranking mode model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+from .knowledge_types import RerankingModelName, RerankingProviderName
+
+
+class RerankingMode(BaseModel):
+    """Reranking mode model with builder pattern."""
+
+    reranking_provider_name: Optional[RerankingProviderName] = None
+    reranking_model_name: Optional[RerankingModelName] = None
+
+    @staticmethod
+    def builder() -> "RerankingModeBuilder":
+        return RerankingModeBuilder()
+
+
+class RerankingModeBuilder:
+    """Builder for RerankingMode."""
+
+    def __init__(self):
+        self._reranking_mode = RerankingMode()
+
+    def build(self) -> RerankingMode:
+        return self._reranking_mode
+
+    def reranking_provider_name(self, reranking_provider_name: RerankingProviderName) -> "RerankingModeBuilder":
+        self._reranking_mode.reranking_provider_name = reranking_provider_name
+        return self
+
+    def reranking_model_name(self, reranking_model_name: RerankingModelName) -> "RerankingModeBuilder":
+        self._reranking_mode.reranking_model_name = reranking_model_name
+        return self

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

@@ -0,0 +1,47 @@
+"""Reranking model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+from .model_credentials import ModelCredentials
+from .model_parameters import ModelParameters
+
+
+class RerankingModel(BaseModel):
+    """Reranking model with builder pattern."""
+
+    model: Optional[str] = None
+    provider: Optional[str] = None
+    credentials: Optional[ModelCredentials] = None
+    model_parameters: Optional[ModelParameters] = None
+
+    @staticmethod
+    def builder() -> "RerankingModelBuilder":
+        return RerankingModelBuilder()
+
+
+class RerankingModelBuilder:
+    """Builder for RerankingModel."""
+
+    def __init__(self):
+        self._reranking_model = RerankingModel()
+
+    def build(self) -> RerankingModel:
+        return self._reranking_model
+
+    def model(self, model: str) -> "RerankingModelBuilder":
+        self._reranking_model.model = model
+        return self
+
+    def provider(self, provider: str) -> "RerankingModelBuilder":
+        self._reranking_model.provider = provider
+        return self
+
+    def credentials(self, credentials: ModelCredentials) -> "RerankingModelBuilder":
+        self._reranking_model.credentials = credentials
+        return self
+
+    def model_parameters(self, model_parameters: ModelParameters) -> "RerankingModelBuilder":
+        self._reranking_model.model_parameters = model_parameters
+        return self

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

@@ -0,0 +1,62 @@
+"""Retrieval model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+from .knowledge_types import SearchMethod
+from .reranking_mode import RerankingMode
+
+
+class RetrievalModel(BaseModel):
+    """Retrieval model with builder pattern."""
+
+    search_method: Optional[SearchMethod] = None
+    reranking_enable: Optional[bool] = None
+    reranking_mode: Optional[RerankingMode] = None
+    top_k: Optional[int] = None
+    score_threshold_enabled: Optional[bool] = None
+    score_threshold: Optional[float] = None
+    weights: Optional[float] = None
+
+    @staticmethod
+    def builder() -> "RetrievalModelBuilder":
+        return RetrievalModelBuilder()
+
+
+class RetrievalModelBuilder:
+    """Builder for RetrievalModel."""
+
+    def __init__(self):
+        self._retrieval_model = RetrievalModel()
+
+    def build(self) -> RetrievalModel:
+        return self._retrieval_model
+
+    def search_method(self, search_method: SearchMethod) -> "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_mode(self, reranking_mode: RerankingMode) -> "RetrievalModelBuilder":
+        self._retrieval_model.reranking_mode = reranking_mode
+        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
+
+    def weights(self, weights: float) -> "RetrievalModelBuilder":
+        self._retrieval_model.weights = weights
+        return self

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

@@ -0,0 +1,28 @@
+from pydantic import BaseModel
+
+from .retrieval_segment_info import RetrievalSegmentInfo
+
+
+class RetrievalRecord(BaseModel):
+    segment: RetrievalSegmentInfo | None = None
+    score: float | None = None
+
+    @staticmethod
+    def builder() -> "RetrievalRecordBuilder":
+        return RetrievalRecordBuilder()
+
+
+class RetrievalRecordBuilder:
+    def __init__(self) -> None:
+        self._retrieval_record = RetrievalRecord()
+
+    def build(self) -> RetrievalRecord:
+        return self._retrieval_record
+
+    def segment(self, segment: RetrievalSegmentInfo) -> "RetrievalRecordBuilder":
+        self._retrieval_record.segment = segment
+        return self
+
+    def score(self, score: float) -> "RetrievalRecordBuilder":
+        self._retrieval_record.score = score
+        return self

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

@@ -0,0 +1,41 @@
+"""Retrieval segment information model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+from .segment_document_info import SegmentDocumentInfo
+
+
+class RetrievalSegmentInfo(BaseModel):
+    """Retrieval segment information model with builder pattern."""
+
+    id: Optional[str] = None
+    content: Optional[str] = None
+    document: Optional[SegmentDocumentInfo] = None
+
+    @staticmethod
+    def builder() -> "RetrievalSegmentInfoBuilder":
+        return RetrievalSegmentInfoBuilder()
+
+
+class RetrievalSegmentInfoBuilder:
+    """Builder for RetrievalSegmentInfo."""
+
+    def __init__(self):
+        self._retrieval_segment_info = RetrievalSegmentInfo()
+
+    def build(self) -> RetrievalSegmentInfo:
+        return self._retrieval_segment_info
+
+    def id(self, id: str) -> "RetrievalSegmentInfoBuilder":
+        self._retrieval_segment_info.id = id
+        return self
+
+    def content(self, content: str) -> "RetrievalSegmentInfoBuilder":
+        self._retrieval_segment_info.content = content
+        return self
+
+    def document(self, document: SegmentDocumentInfo) -> "RetrievalSegmentInfoBuilder":
+        self._retrieval_segment_info.document = document
+        return self

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

@@ -0,0 +1,36 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .retrieve_from_dataset_request_body import RetrieveFromDatasetRequestBody
+
+
+class RetrieveFromDatasetRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.request_body: RetrieveFromDatasetRequestBody | None = None
+
+    @staticmethod
+    def builder() -> "RetrieveFromDatasetRequestBuilder":
+        return RetrieveFromDatasetRequestBuilder()
+
+
+class RetrieveFromDatasetRequestBuilder:
+    def __init__(self) -> None:
+        retrieve_from_dataset_request = RetrieveFromDatasetRequest()
+        retrieve_from_dataset_request.http_method = HttpMethod.POST
+        retrieve_from_dataset_request.uri = "/v1/datasets/:dataset_id/retrieve"
+        self._retrieve_from_dataset_request = retrieve_from_dataset_request
+
+    def build(self) -> RetrieveFromDatasetRequest:
+        return self._retrieve_from_dataset_request
+
+    def dataset_id(self, dataset_id: str) -> "RetrieveFromDatasetRequestBuilder":
+        self._retrieve_from_dataset_request.dataset_id = dataset_id
+        self._retrieve_from_dataset_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def request_body(self, request_body: RetrieveFromDatasetRequestBody) -> "RetrieveFromDatasetRequestBuilder":
+        self._retrieve_from_dataset_request.request_body = request_body
+        self._retrieve_from_dataset_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

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

@@ -0,0 +1,38 @@
+from pydantic import BaseModel
+
+from .retrieval_model import RetrievalModel
+
+
+class RetrieveFromDatasetRequestBody(BaseModel):
+    query: str | None = None
+    retrieval_model: RetrievalModel | None = None
+    top_k: int | None = None
+    score_threshold: float | None = None
+
+    @staticmethod
+    def builder() -> "RetrieveFromDatasetRequestBodyBuilder":
+        return RetrieveFromDatasetRequestBodyBuilder()
+
+
+class RetrieveFromDatasetRequestBodyBuilder:
+    def __init__(self) -> None:
+        self._retrieve_from_dataset_request_body = RetrieveFromDatasetRequestBody()
+
+    def build(self) -> RetrieveFromDatasetRequestBody:
+        return self._retrieve_from_dataset_request_body
+
+    def query(self, query: str) -> "RetrieveFromDatasetRequestBodyBuilder":
+        self._retrieve_from_dataset_request_body.query = query
+        return self
+
+    def retrieval_model(self, retrieval_model: RetrievalModel) -> "RetrieveFromDatasetRequestBodyBuilder":
+        self._retrieve_from_dataset_request_body.retrieval_model = retrieval_model
+        return self
+
+    def top_k(self, top_k: int) -> "RetrieveFromDatasetRequestBodyBuilder":
+        self._retrieve_from_dataset_request_body.top_k = top_k
+        return self
+
+    def score_threshold(self, score_threshold: float) -> "RetrieveFromDatasetRequestBodyBuilder":
+        self._retrieve_from_dataset_request_body.score_threshold = score_threshold
+        return self

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

@@ -0,0 +1,9 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .query_info import QueryInfo
+from .retrieval_record import RetrievalRecord
+
+
+class RetrieveFromDatasetResponse(BaseResponse):
+    query: QueryInfo | None = None
+    records: list[RetrievalRecord] | None = None

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