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

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

@@ -0,0 +1,100 @@
+"""Knowledge Base API type definitions using Literal types for type safety."""
+
+from typing import Literal
+
+# Indexing technique types
+IndexingTechnique = Literal["high_quality", "economy"]
+
+# Permission types
+Permission = Literal["only_me", "all_team_members", "partial_members"]
+
+# Search method types
+SearchMethod = Literal["hybrid_search", "semantic_search", "full_text_search", "keyword_search"]
+
+# Document status types
+DocumentStatus = Literal["indexing", "completed", "error", "paused"]
+
+# Processing mode types
+ProcessingMode = Literal["automatic", "custom"]
+
+# File types
+FileType = Literal["document", "image", "audio", "video", "custom"]
+
+# Transfer method types
+TransferMethod = Literal["remote_url", "local_file"]
+
+# Tag types
+TagType = Literal["knowledge", "custom"]
+
+# Segment status types
+SegmentStatus = Literal["waiting", "parsing", "cleaning", "splitting", "indexing", "completed", "error", "paused"]
+
+# Document status action types
+DocumentStatusAction = Literal["enable", "disable", "archive", "un_archive"]
+
+# Document form types
+DocumentForm = Literal["text_model", "hierarchical_model", "qa_model"]
+
+# Model types
+ModelType = Literal["text-embedding"]
+
+# Provider types
+ProviderType = Literal["vendor", "external"]
+
+# Data source types
+DataSourceType = Literal["upload_file", "notion_import", "website_crawl"]
+
+# Dataset types
+DatasetType = Literal["knowledge_base", "external_api"]
+
+# Indexing status types
+IndexingStatus = Literal["waiting", "parsing", "cleaning", "splitting", "indexing", "completed", "error", "paused"]
+
+# Reranking model configuration types
+RerankingProviderName = str  # Dynamic provider names
+RerankingModelName = str  # Dynamic model names
+
+# Preprocessing rule types
+PreprocessingRuleId = Literal["remove_extra_spaces", "remove_urls_emails"]
+
+# Parent mode types for hierarchical processing
+ParentMode = Literal["full-doc", "paragraph"]
+
+# Model status types
+ModelStatus = Literal["active", "inactive", "deprecated"]
+
+# Model fetch source types
+ModelFetchFrom = Literal["predefined-model", "customizable-model"]
+
+# Model feature types
+ModelFeature = Literal["embedding", "reranking"]
+
+# Tag binding target types
+TagBindingTarget = Literal["dataset", "document"]
+
+# External knowledge provider types
+ExternalKnowledgeProvider = Literal["external_api", "notion", "web_crawler"]
+
+# Document creation source types
+DocumentCreatedFrom = Literal["api", "web", "upload"]
+
+# Document display status types
+DocumentDisplayStatus = Literal["available", "indexing", "error", "paused", "archived"]
+
+# Batch processing status types
+BatchProcessingStatus = Literal["processing", "completed", "failed", "cancelled"]
+
+# File extension types (common ones)
+FileExtension = Literal["pdf", "doc", "docx", "txt", "md", "html", "csv", "xlsx", "ppt", "pptx"]
+
+# MIME type categories
+MimeTypeCategory = Literal["application", "text", "image", "audio", "video"]
+
+# Chunk processing status
+ChunkStatus = Literal["waiting", "processing", "completed", "error"]
+
+# Query content type
+QueryContentType = Literal["text", "structured"]
+
+# Retrieval record score type
+RetrievalScoreType = Literal["cosine", "dot_product", "euclidean"]

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

@@ -1,3 +1,5 @@
+"""List child chunks request model."""
+
 from __future__ import annotations
 
 from dify_oapi.core.enum import HttpMethod
@@ -5,7 +7,9 @@ from dify_oapi.core.model.base_request import BaseRequest
 
 
 class ListChildChunksRequest(BaseRequest):
-    def __init__(self):
+    """Request model for list child chunks API."""
+
+    def __init__(self) -> None:
         super().__init__()
         self.dataset_id: str | None = None
         self.document_id: str | None = None
@@ -17,7 +21,9 @@ class ListChildChunksRequest(BaseRequest):
 
 
 class ListChildChunksRequestBuilder:
-    def __init__(self):
+    """Builder for ListChildChunksRequest."""
+
+    def __init__(self) -> None:
         list_child_chunks_request = ListChildChunksRequest()
         list_child_chunks_request.http_method = HttpMethod.GET
         list_child_chunks_request.uri = (
@@ -48,9 +54,9 @@ class ListChildChunksRequestBuilder:
         return self
 
     def page(self, page: int) -> ListChildChunksRequestBuilder:
-        self._list_child_chunks_request.add_query("page", page)
+        self._list_child_chunks_request.add_query("page", str(page))
         return self
 
     def limit(self, limit: int) -> ListChildChunksRequestBuilder:
-        self._list_child_chunks_request.add_query("limit", limit)
+        self._list_child_chunks_request.add_query("limit", str(limit))
         return self

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

@@ -1,9 +1,13 @@
+"""List child chunks response model."""
+
 from dify_oapi.core.model.base_response import BaseResponse
 
 from .child_chunk_info import ChildChunkInfo
 
 
 class ListChildChunksResponse(BaseResponse):
+    """Response model for list child chunks API."""
+
     data: list[ChildChunkInfo] | None = None
     total: int | None = None
     total_pages: int | None = None

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

@@ -0,0 +1,30 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class ListDatasetsRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+
+    @staticmethod
+    def builder() -> "ListDatasetsRequestBuilder":
+        return ListDatasetsRequestBuilder()
+
+
+class ListDatasetsRequestBuilder:
+    def __init__(self) -> None:
+        list_datasets_request = ListDatasetsRequest()
+        list_datasets_request.http_method = HttpMethod.GET
+        list_datasets_request.uri = "/v1/datasets"
+        self._list_datasets_request = list_datasets_request
+
+    def build(self) -> ListDatasetsRequest:
+        return self._list_datasets_request
+
+    def page(self, page: int) -> "ListDatasetsRequestBuilder":
+        self._list_datasets_request.add_query("page", str(page))
+        return self
+
+    def limit(self, limit: int) -> "ListDatasetsRequestBuilder":
+        self._list_datasets_request.add_query("limit", str(limit))
+        return self

dify_oapi/api/{knowledge_base/v1/model/dataset/list_response.py → knowledge/v1/model/list_datasets_response.py}

@@ -1,11 +1,9 @@
-from __future__ import annotations
-
 from dify_oapi.core.model.base_response import BaseResponse
 
 from .dataset_info import DatasetInfo
 
 
-class ListResponse(BaseResponse):
+class ListDatasetsResponse(BaseResponse):
     data: list[DatasetInfo] | None = None
     has_more: bool | None = None
     limit: int | None = None

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

@@ -0,0 +1,48 @@
+"""List documents request model."""
+
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class ListDocumentsRequest(BaseRequest):
+    """Request model for list documents API."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+
+    @staticmethod
+    def builder() -> ListDocumentsRequestBuilder:
+        return ListDocumentsRequestBuilder()
+
+
+class ListDocumentsRequestBuilder:
+    """Builder for ListDocumentsRequest."""
+
+    def __init__(self) -> None:
+        list_documents_request = ListDocumentsRequest()
+        list_documents_request.http_method = HttpMethod.GET
+        list_documents_request.uri = "/v1/datasets/:dataset_id/documents"
+        self._list_documents_request = list_documents_request
+
+    def build(self) -> ListDocumentsRequest:
+        return self._list_documents_request
+
+    def dataset_id(self, dataset_id: str) -> ListDocumentsRequestBuilder:
+        self._list_documents_request.dataset_id = dataset_id
+        self._list_documents_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def keyword(self, keyword: str) -> ListDocumentsRequestBuilder:
+        self._list_documents_request.add_query("keyword", keyword)
+        return self
+
+    def page(self, page: int) -> ListDocumentsRequestBuilder:
+        self._list_documents_request.add_query("page", str(page))
+        return self
+
+    def limit(self, limit: int) -> ListDocumentsRequestBuilder:
+        self._list_documents_request.add_query("limit", str(limit))
+        return self

dify_oapi/api/{knowledge_base/v1/model/document/list_response.py → knowledge/v1/model/list_documents_response.py}

@@ -1,12 +1,12 @@
-from __future__ import annotations
+"""List documents response model."""
 
 from dify_oapi.core.model.base_response import BaseResponse
 
 from .document_info import DocumentInfo
 
 
-class ListResponse(BaseResponse):
-    """Response model for list documents API"""
+class ListDocumentsResponse(BaseResponse):
+    """Response model for list documents API."""
 
     data: list[DocumentInfo] | None = None
     has_more: bool | None = None

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

@@ -0,0 +1,60 @@
+"""List segments request model."""
+
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .knowledge_types import SegmentStatus
+
+
+class ListSegmentsRequest(BaseRequest):
+    """Request model for list segments API."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.document_id: str | None = None
+
+    @staticmethod
+    def builder() -> ListSegmentsRequestBuilder:
+        return ListSegmentsRequestBuilder()
+
+
+class ListSegmentsRequestBuilder:
+    """Builder for ListSegmentsRequest."""
+
+    def __init__(self) -> None:
+        list_segments_request = ListSegmentsRequest()
+        list_segments_request.http_method = HttpMethod.GET
+        list_segments_request.uri = "/v1/datasets/:dataset_id/documents/:document_id/segments"
+        self._list_segments_request = list_segments_request
+
+    def build(self) -> ListSegmentsRequest:
+        return self._list_segments_request
+
+    def dataset_id(self, dataset_id: str) -> ListSegmentsRequestBuilder:
+        self._list_segments_request.dataset_id = dataset_id
+        self._list_segments_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def document_id(self, document_id: str) -> ListSegmentsRequestBuilder:
+        self._list_segments_request.document_id = document_id
+        self._list_segments_request.paths["document_id"] = document_id
+        return self
+
+    def keyword(self, keyword: str) -> ListSegmentsRequestBuilder:
+        self._list_segments_request.add_query("keyword", keyword)
+        return self
+
+    def status(self, status: SegmentStatus) -> ListSegmentsRequestBuilder:
+        self._list_segments_request.add_query("status", status)
+        return self
+
+    def page(self, page: int) -> ListSegmentsRequestBuilder:
+        self._list_segments_request.add_query("page", str(page))
+        return self
+
+    def limit(self, limit: int) -> ListSegmentsRequestBuilder:
+        self._list_segments_request.add_query("limit", str(limit))
+        return self

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

@@ -1,11 +1,14 @@
+"""List segments response model."""
+
 from dify_oapi.core.model.base_response import BaseResponse
 
 from .segment_info import SegmentInfo
 
 
-class ListResponse(BaseResponse):
+class ListSegmentsResponse(BaseResponse):
+    """Response model for list segments API."""
+
     data: list[SegmentInfo] | None = None
-    doc_form: str | None = None
     has_more: bool | None = None
     limit: int | None = None
     total: int | None = None

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

@@ -0,0 +1,28 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .knowledge_types import TagType
+
+
+class ListTagsRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def builder() -> "ListTagsRequestBuilder":
+        return ListTagsRequestBuilder()
+
+
+class ListTagsRequestBuilder:
+    def __init__(self):
+        list_tags_request = ListTagsRequest()
+        list_tags_request.http_method = HttpMethod.GET
+        list_tags_request.uri = "/v1/datasets/tags"
+        self._list_tags_request = list_tags_request
+
+    def build(self) -> ListTagsRequest:
+        return self._list_tags_request
+
+    def type(self, type_value: TagType) -> "ListTagsRequestBuilder":
+        self._list_tags_request.add_query("type", type_value)
+        return self

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

@@ -0,0 +1,7 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .tag_info import TagInfo
+
+
+class ListTagsResponse(BaseResponse):
+    data: list[TagInfo] | None = None

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