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

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

@@ -0,0 +1,34 @@
+"""Model credentials for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class ModelCredentials(BaseModel):
+    """Model credentials with builder pattern."""
+
+    api_key: Optional[str] = None
+    api_base: Optional[str] = None
+
+    @staticmethod
+    def builder() -> "ModelCredentialsBuilder":
+        return ModelCredentialsBuilder()
+
+
+class ModelCredentialsBuilder:
+    """Builder for ModelCredentials."""
+
+    def __init__(self):
+        self._model_credentials = ModelCredentials()
+
+    def build(self) -> ModelCredentials:
+        return self._model_credentials
+
+    def api_key(self, api_key: str) -> "ModelCredentialsBuilder":
+        self._model_credentials.api_key = api_key
+        return self
+
+    def api_base(self, api_base: str) -> "ModelCredentialsBuilder":
+        self._model_credentials.api_base = api_base
+        return self

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

@@ -0,0 +1,85 @@
+"""Model information model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+from .knowledge_types import ModelFeature, ModelFetchFrom, ModelStatus
+from .model_parameters import ModelParameters
+
+
+class ModelLabel(BaseModel):
+    """Model label with localization support."""
+
+    en_US: Optional[str] = None  # noqa: N815
+    zh_Hans: Optional[str] = None  # noqa: N815
+
+
+class ModelIcon(BaseModel):
+    """Model icon with different sizes."""
+
+    en_US: Optional[str] = None  # noqa: N815
+    zh_Hans: Optional[str] = None  # noqa: N815
+
+
+class EmbeddingModelDetails(BaseModel):
+    """Individual embedding model details."""
+
+    model: Optional[str] = None
+    label: Optional[ModelLabel] = None
+    model_type: Optional[str] = None
+    features: Optional[list[ModelFeature]] = None
+    fetch_from: Optional[ModelFetchFrom] = None
+    model_properties: Optional[ModelParameters] = None
+    deprecated: Optional[bool] = None
+    status: Optional[ModelStatus] = None
+    load_balancing_enabled: Optional[bool] = None
+
+
+class ModelInfo(BaseModel):
+    """Model provider information with embedding models."""
+
+    provider: Optional[str] = None
+    label: Optional[ModelLabel] = None
+    icon_small: Optional[ModelIcon] = None
+    icon_large: Optional[ModelIcon] = None
+    status: Optional[ModelStatus] = None
+    models: Optional[list[EmbeddingModelDetails]] = None
+
+    @staticmethod
+    def builder() -> "ModelInfoBuilder":
+        return ModelInfoBuilder()
+
+
+class ModelInfoBuilder:
+    """Builder for ModelInfo."""
+
+    def __init__(self):
+        self._model_info = ModelInfo()
+
+    def build(self) -> ModelInfo:
+        return self._model_info
+
+    def provider(self, provider: str) -> "ModelInfoBuilder":
+        self._model_info.provider = provider
+        return self
+
+    def label(self, label: ModelLabel) -> "ModelInfoBuilder":
+        self._model_info.label = label
+        return self
+
+    def icon_small(self, icon_small: ModelIcon) -> "ModelInfoBuilder":
+        self._model_info.icon_small = icon_small
+        return self
+
+    def icon_large(self, icon_large: ModelIcon) -> "ModelInfoBuilder":
+        self._model_info.icon_large = icon_large
+        return self
+
+    def status(self, status: ModelStatus) -> "ModelInfoBuilder":
+        self._model_info.status = status
+        return self
+
+    def models(self, models: list[EmbeddingModelDetails]) -> "ModelInfoBuilder":
+        self._model_info.models = models
+        return self

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

@@ -0,0 +1,34 @@
+"""Model parameters for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class ModelParameters(BaseModel):
+    """Model parameters with builder pattern."""
+
+    context_size: Optional[int] = None
+    max_chunks: Optional[int] = None
+
+    @staticmethod
+    def builder() -> "ModelParametersBuilder":
+        return ModelParametersBuilder()
+
+
+class ModelParametersBuilder:
+    """Builder for ModelParameters."""
+
+    def __init__(self):
+        self._model_parameters = ModelParameters()
+
+    def build(self) -> ModelParameters:
+        return self._model_parameters
+
+    def context_size(self, context_size: int) -> "ModelParametersBuilder":
+        self._model_parameters.context_size = context_size
+        return self
+
+    def max_chunks(self, max_chunks: int) -> "ModelParametersBuilder":
+        self._model_parameters.max_chunks = max_chunks
+        return self

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

@@ -0,0 +1,44 @@
+"""Pagination information model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class PaginationInfo(BaseModel):
+    """Pagination information model with builder pattern."""
+
+    page: Optional[int] = None
+    limit: Optional[int] = None
+    total: Optional[int] = None
+    has_more: Optional[bool] = None
+
+    @staticmethod
+    def builder() -> "PaginationInfoBuilder":
+        return PaginationInfoBuilder()
+
+
+class PaginationInfoBuilder:
+    """Builder for PaginationInfo."""
+
+    def __init__(self):
+        self._pagination_info = PaginationInfo()
+
+    def build(self) -> PaginationInfo:
+        return self._pagination_info
+
+    def page(self, page: int) -> "PaginationInfoBuilder":
+        self._pagination_info.page = page
+        return self
+
+    def limit(self, limit: int) -> "PaginationInfoBuilder":
+        self._pagination_info.limit = limit
+        return self
+
+    def total(self, total: int) -> "PaginationInfoBuilder":
+        self._pagination_info.total = total
+        return self
+
+    def has_more(self, has_more: bool) -> "PaginationInfoBuilder":
+        self._pagination_info.has_more = has_more
+        return self

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

@@ -0,0 +1,36 @@
+"""Preprocessing rule model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+from .knowledge_types import PreprocessingRuleId
+
+
+class PreprocessingRule(BaseModel):
+    """Preprocessing rule model with builder pattern."""
+
+    id: Optional[PreprocessingRuleId] = None
+    enabled: Optional[bool] = None
+
+    @staticmethod
+    def builder() -> "PreprocessingRuleBuilder":
+        return PreprocessingRuleBuilder()
+
+
+class PreprocessingRuleBuilder:
+    """Builder for PreprocessingRule."""
+
+    def __init__(self):
+        self._preprocessing_rule = PreprocessingRule()
+
+    def build(self) -> PreprocessingRule:
+        return self._preprocessing_rule
+
+    def id(self, id: PreprocessingRuleId) -> "PreprocessingRuleBuilder":
+        self._preprocessing_rule.id = id
+        return self
+
+    def enabled(self, enabled: bool) -> "PreprocessingRuleBuilder":
+        self._preprocessing_rule.enabled = enabled
+        return self

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

@@ -0,0 +1,43 @@
+"""Process rule model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+from .knowledge_types import ProcessingMode
+from .process_rules import ProcessRules
+from .segmentation_rule import SegmentationRule
+
+
+class ProcessRule(BaseModel):
+    """Process rule model with builder pattern."""
+
+    mode: Optional[ProcessingMode] = None
+    rules: Optional[ProcessRules] = None
+    segmentation: Optional[SegmentationRule] = None
+
+    @staticmethod
+    def builder() -> "ProcessRuleBuilder":
+        return ProcessRuleBuilder()
+
+
+class ProcessRuleBuilder:
+    """Builder for ProcessRule."""
+
+    def __init__(self):
+        self._process_rule = ProcessRule()
+
+    def build(self) -> ProcessRule:
+        return self._process_rule
+
+    def mode(self, mode: ProcessingMode) -> "ProcessRuleBuilder":
+        self._process_rule.mode = mode
+        return self
+
+    def rules(self, rules: ProcessRules) -> "ProcessRuleBuilder":
+        self._process_rule.rules = rules
+        return self
+
+    def segmentation(self, segmentation: SegmentationRule) -> "ProcessRuleBuilder":
+        self._process_rule.segmentation = segmentation
+        return self

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