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

dify_oapi/api/completion/v1/model/info/user_input_form.py

@@ -1,19 +1,60 @@
 from __future__ import annotations
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 
-class UserInputForm(BaseModel):
-    label: str | None = None
-    variable: str | None = None
-    required: bool | None = None
+class TextInputControl(BaseModel):
+    """Text input control configuration."""
+
+    label: str
+    variable: str
+    required: bool
+    default: str | None = None
+
+
+class ParagraphControl(BaseModel):
+    """Paragraph (multi-line text) control configuration."""
+
+    label: str
+    variable: str
+    required: bool
     default: str | None = None
-    options: list[str] | None = None
+
+
+class SelectControl(BaseModel):
+    """Select (dropdown) control configuration."""
+
+    label: str
+    variable: str
+    required: bool
+    default: str | None = None
+    options: list[str]
+
+
+class UserInputForm(BaseModel):
+    """User input form configuration supporting different control types."""
+
+    # Use discriminated union to support different form control types
+    text_input: TextInputControl | None = Field(default=None, alias="text-input")
+    paragraph: ParagraphControl | None = None
+    select: SelectControl | None = None
 
     @staticmethod
     def builder() -> UserInputFormBuilder:
         return UserInputFormBuilder()
 
+    @staticmethod
+    def text_input_builder() -> TextInputFormBuilder:
+        return TextInputFormBuilder()
+
+    @staticmethod
+    def paragraph_builder() -> ParagraphFormBuilder:
+        return ParagraphFormBuilder()
+
+    @staticmethod
+    def select_builder() -> SelectFormBuilder:
+        return SelectFormBuilder()
+
 
 class UserInputFormBuilder:
     def __init__(self):
@@ -22,22 +63,96 @@ class UserInputFormBuilder:
     def build(self) -> UserInputForm:
         return self._user_input_form
 
-    def label(self, label: str) -> UserInputFormBuilder:
-        self._user_input_form.label = label
+    def text_input(self, text_input: TextInputControl) -> UserInputFormBuilder:
+        self._user_input_form.text_input = text_input
+        return self
+
+    def paragraph(self, paragraph: ParagraphControl) -> UserInputFormBuilder:
+        self._user_input_form.paragraph = paragraph
+        return self
+
+    def select(self, select: SelectControl) -> UserInputFormBuilder:
+        self._user_input_form.select = select
+        return self
+
+
+class TextInputFormBuilder:
+    def __init__(self):
+        self._control = TextInputControl(label="", variable="", required=False)
+
+    def build(self) -> UserInputForm:
+        form = UserInputForm()
+        form.text_input = self._control
+        return form
+
+    def label(self, label: str) -> TextInputFormBuilder:
+        self._control.label = label
+        return self
+
+    def variable(self, variable: str) -> TextInputFormBuilder:
+        self._control.variable = variable
+        return self
+
+    def required(self, required: bool) -> TextInputFormBuilder:
+        self._control.required = required
+        return self
+
+    def default(self, default: str) -> TextInputFormBuilder:
+        self._control.default = default
+        return self
+
+
+class ParagraphFormBuilder:
+    def __init__(self):
+        self._control = ParagraphControl(label="", variable="", required=False)
+
+    def build(self) -> UserInputForm:
+        form = UserInputForm()
+        form.paragraph = self._control
+        return form
+
+    def label(self, label: str) -> ParagraphFormBuilder:
+        self._control.label = label
+        return self
+
+    def variable(self, variable: str) -> ParagraphFormBuilder:
+        self._control.variable = variable
+        return self
+
+    def required(self, required: bool) -> ParagraphFormBuilder:
+        self._control.required = required
+        return self
+
+    def default(self, default: str) -> ParagraphFormBuilder:
+        self._control.default = default
+        return self
+
+
+class SelectFormBuilder:
+    def __init__(self):
+        self._control = SelectControl(label="", variable="", required=False, options=[])
+
+    def build(self) -> UserInputForm:
+        form = UserInputForm()
+        form.select = self._control
+        return form
+
+    def label(self, label: str) -> SelectFormBuilder:
+        self._control.label = label
         return self
 
-    def variable(self, variable: str) -> UserInputFormBuilder:
-        self._user_input_form.variable = variable
+    def variable(self, variable: str) -> SelectFormBuilder:
+        self._control.variable = variable
         return self
 
-    def required(self, required: bool) -> UserInputFormBuilder:
-        self._user_input_form.required = required
+    def required(self, required: bool) -> SelectFormBuilder:
+        self._control.required = required
         return self
 
-    def default(self, default: str) -> UserInputFormBuilder:
-        self._user_input_form.default = default
+    def default(self, default: str) -> SelectFormBuilder:
+        self._control.default = default
         return self
 
-    def options(self, options: list[str]) -> UserInputFormBuilder:
-        self._user_input_form.options = options
+    def options(self, options: list[str]) -> SelectFormBuilder:
+        self._control.options = options
         return self

dify_oapi/api/knowledge/service.py

@@ -0,0 +1,8 @@
+from dify_oapi.core.model.config import Config
+
+from .v1.version import V1
+
+
+class Knowledge:
+    def __init__(self, config: Config):
+        self.v1 = V1(config)

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

@@ -0,0 +1,86 @@
+"""Batch information model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+from .knowledge_types import IndexingStatus
+
+
+class BatchInfo(BaseModel):
+    """Batch information model with builder pattern."""
+
+    id: Optional[str] = None
+    indexing_status: Optional[IndexingStatus] = None
+    processing_started_at: Optional[float] = None
+    parsing_completed_at: Optional[float] = None
+    cleaning_completed_at: Optional[float] = None
+    splitting_completed_at: Optional[float] = None
+    completed_at: Optional[float] = None
+    paused_at: Optional[float] = None
+    error: Optional[str] = None
+    stopped_at: Optional[float] = None
+    completed_segments: Optional[int] = None
+    total_segments: Optional[int] = None
+
+    @staticmethod
+    def builder() -> "BatchInfoBuilder":
+        return BatchInfoBuilder()
+
+
+class BatchInfoBuilder:
+    """Builder for BatchInfo."""
+
+    def __init__(self):
+        self._batch_info = BatchInfo()
+
+    def build(self) -> BatchInfo:
+        return self._batch_info
+
+    def id(self, id: str) -> "BatchInfoBuilder":
+        self._batch_info.id = id
+        return self
+
+    def indexing_status(self, indexing_status: IndexingStatus) -> "BatchInfoBuilder":
+        self._batch_info.indexing_status = indexing_status
+        return self
+
+    def processing_started_at(self, processing_started_at: float) -> "BatchInfoBuilder":
+        self._batch_info.processing_started_at = processing_started_at
+        return self
+
+    def parsing_completed_at(self, parsing_completed_at: float) -> "BatchInfoBuilder":
+        self._batch_info.parsing_completed_at = parsing_completed_at
+        return self
+
+    def cleaning_completed_at(self, cleaning_completed_at: float) -> "BatchInfoBuilder":
+        self._batch_info.cleaning_completed_at = cleaning_completed_at
+        return self
+
+    def splitting_completed_at(self, splitting_completed_at: float) -> "BatchInfoBuilder":
+        self._batch_info.splitting_completed_at = splitting_completed_at
+        return self
+
+    def completed_at(self, completed_at: float) -> "BatchInfoBuilder":
+        self._batch_info.completed_at = completed_at
+        return self
+
+    def paused_at(self, paused_at: float) -> "BatchInfoBuilder":
+        self._batch_info.paused_at = paused_at
+        return self
+
+    def error(self, error: str) -> "BatchInfoBuilder":
+        self._batch_info.error = error
+        return self
+
+    def stopped_at(self, stopped_at: float) -> "BatchInfoBuilder":
+        self._batch_info.stopped_at = stopped_at
+        return self
+
+    def completed_segments(self, completed_segments: int) -> "BatchInfoBuilder":
+        self._batch_info.completed_segments = completed_segments
+        return self
+
+    def total_segments(self, total_segments: int) -> "BatchInfoBuilder":
+        self._batch_info.total_segments = total_segments
+        return self

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

@@ -0,0 +1,30 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .bind_tags_to_dataset_request_body import BindTagsToDatasetRequestBody
+
+
+class BindTagsToDatasetRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.request_body: BindTagsToDatasetRequestBody | None = None
+
+    @staticmethod
+    def builder() -> "BindTagsToDatasetRequestBuilder":
+        return BindTagsToDatasetRequestBuilder()
+
+
+class BindTagsToDatasetRequestBuilder:
+    def __init__(self):
+        bind_tags_to_dataset_request = BindTagsToDatasetRequest()
+        bind_tags_to_dataset_request.http_method = HttpMethod.POST
+        bind_tags_to_dataset_request.uri = "/v1/datasets/tags/binding"
+        self._bind_tags_to_dataset_request = bind_tags_to_dataset_request
+
+    def build(self) -> BindTagsToDatasetRequest:
+        return self._bind_tags_to_dataset_request
+
+    def request_body(self, request_body: BindTagsToDatasetRequestBody) -> "BindTagsToDatasetRequestBuilder":
+        self._bind_tags_to_dataset_request.request_body = request_body
+        self._bind_tags_to_dataset_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

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

@@ -0,0 +1,26 @@
+from pydantic import BaseModel
+
+
+class BindTagsToDatasetRequestBody(BaseModel):
+    target_id: str | None = None
+    tag_ids: list[str] | None = None
+
+    @staticmethod
+    def builder() -> "BindTagsToDatasetRequestBodyBuilder":
+        return BindTagsToDatasetRequestBodyBuilder()
+
+
+class BindTagsToDatasetRequestBodyBuilder:
+    def __init__(self):
+        self._bind_tags_to_dataset_request_body = BindTagsToDatasetRequestBody()
+
+    def build(self) -> BindTagsToDatasetRequestBody:
+        return self._bind_tags_to_dataset_request_body
+
+    def target_id(self, target_id: str) -> "BindTagsToDatasetRequestBodyBuilder":
+        self._bind_tags_to_dataset_request_body.target_id = target_id
+        return self
+
+    def tag_ids(self, tag_ids: list[str]) -> "BindTagsToDatasetRequestBodyBuilder":
+        self._bind_tags_to_dataset_request_body.tag_ids = tag_ids
+        return self

dify_oapi/api/{knowledge_base/v1/model/tag/delete_response.py → knowledge/v1/model/bind_tags_to_dataset_response.py}

@@ -1,7 +1,5 @@
-from __future__ import annotations
-
 from dify_oapi.core.model.base_response import BaseResponse
 
 
-class DeleteResponse(BaseResponse):
+class BindTagsToDatasetResponse(BaseResponse):
     result: str | None = None

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

@@ -0,0 +1,34 @@
+"""Child chunk content model for Knowledge Base API."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class ChildChunkContent(BaseModel):
+    """Child chunk content model with builder pattern."""
+
+    content: str | None = None
+    keywords: list[str] | None = None
+
+    @staticmethod
+    def builder() -> ChildChunkContentBuilder:
+        return ChildChunkContentBuilder()
+
+
+class ChildChunkContentBuilder:
+    """Builder for ChildChunkContent."""
+
+    def __init__(self) -> None:
+        self._child_chunk_content = ChildChunkContent()
+
+    def build(self) -> ChildChunkContent:
+        return self._child_chunk_content
+
+    def content(self, content: str) -> ChildChunkContentBuilder:
+        self._child_chunk_content.content = content
+        return self
+
+    def keywords(self, keywords: list[str]) -> ChildChunkContentBuilder:
+        self._child_chunk_content.keywords = keywords
+        return self

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

@@ -0,0 +1,101 @@
+"""Child chunk information model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+from .knowledge_types import ChunkStatus
+
+
+class ChildChunkInfo(BaseModel):
+    """Child chunk information model with builder pattern."""
+
+    id: Optional[str] = None
+    segment_id: Optional[str] = None
+    content: 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
+    status: Optional[ChunkStatus] = 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() -> "ChildChunkInfoBuilder":
+        return ChildChunkInfoBuilder()
+
+
+class ChildChunkInfoBuilder:
+    """Builder for ChildChunkInfo."""
+
+    def __init__(self):
+        self._child_chunk_info = ChildChunkInfo()
+
+    def build(self) -> ChildChunkInfo:
+        return self._child_chunk_info
+
+    def id(self, id: str) -> "ChildChunkInfoBuilder":
+        self._child_chunk_info.id = id
+        return self
+
+    def content(self, content: str) -> "ChildChunkInfoBuilder":
+        self._child_chunk_info.content = content
+        return self
+
+    def keywords(self, keywords: list[str]) -> "ChildChunkInfoBuilder":
+        self._child_chunk_info.keywords = keywords
+        return self
+
+    def segment_id(self, segment_id: str) -> "ChildChunkInfoBuilder":
+        self._child_chunk_info.segment_id = segment_id
+        return self
+
+    def word_count(self, word_count: int) -> "ChildChunkInfoBuilder":
+        self._child_chunk_info.word_count = word_count
+        return self
+
+    def tokens(self, tokens: int) -> "ChildChunkInfoBuilder":
+        self._child_chunk_info.tokens = tokens
+        return self
+
+    def index_node_id(self, index_node_id: str) -> "ChildChunkInfoBuilder":
+        self._child_chunk_info.index_node_id = index_node_id
+        return self
+
+    def index_node_hash(self, index_node_hash: str) -> "ChildChunkInfoBuilder":
+        self._child_chunk_info.index_node_hash = index_node_hash
+        return self
+
+    def status(self, status: ChunkStatus) -> "ChildChunkInfoBuilder":
+        self._child_chunk_info.status = status
+        return self
+
+    def created_by(self, created_by: str) -> "ChildChunkInfoBuilder":
+        self._child_chunk_info.created_by = created_by
+        return self
+
+    def created_at(self, created_at: float) -> "ChildChunkInfoBuilder":
+        self._child_chunk_info.created_at = created_at
+        return self
+
+    def indexing_at(self, indexing_at: float) -> "ChildChunkInfoBuilder":
+        self._child_chunk_info.indexing_at = indexing_at
+        return self
+
+    def completed_at(self, completed_at: float) -> "ChildChunkInfoBuilder":
+        self._child_chunk_info.completed_at = completed_at
+        return self
+
+    def error(self, error: str) -> "ChildChunkInfoBuilder":
+        self._child_chunk_info.error = error
+        return self
+
+    def stopped_at(self, stopped_at: float) -> "ChildChunkInfoBuilder":
+        self._child_chunk_info.stopped_at = stopped_at
+        return self

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

@@ -1,3 +1,5 @@
+"""Create child chunk request model."""
+
 from __future__ import annotations
 
 from dify_oapi.core.enum import HttpMethod
@@ -7,7 +9,9 @@ from .create_child_chunk_request_body import CreateChildChunkRequestBody
 
 
 class CreateChildChunkRequest(BaseRequest):
-    def __init__(self):
+    """Request model for create child chunk API."""
+
+    def __init__(self) -> None:
         super().__init__()
         self.dataset_id: str | None = None
         self.document_id: str | None = None
@@ -20,7 +24,9 @@ class CreateChildChunkRequest(BaseRequest):
 
 
 class CreateChildChunkRequestBuilder:
-    def __init__(self):
+    """Builder for CreateChildChunkRequest."""
+
+    def __init__(self) -> None:
         create_child_chunk_request = CreateChildChunkRequest()
         create_child_chunk_request.http_method = HttpMethod.POST
         create_child_chunk_request.uri = (

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

@@ -0,0 +1,44 @@
+"""Create child chunk request body model."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class ChunkContent(BaseModel):
+    """Individual chunk content for creation."""
+
+    content: str | None = None
+    keywords: list[str] | None = None
+
+
+class CreateChildChunkRequestBody(BaseModel):
+    """Request body model for create child chunk API."""
+
+    chunks: list[ChunkContent] | None = None
+
+    @staticmethod
+    def builder() -> CreateChildChunkRequestBodyBuilder:
+        return CreateChildChunkRequestBodyBuilder()
+
+
+class CreateChildChunkRequestBodyBuilder:
+    """Builder for CreateChildChunkRequestBody."""
+
+    def __init__(self) -> None:
+        self._create_child_chunk_request_body = CreateChildChunkRequestBody()
+
+    def build(self) -> CreateChildChunkRequestBody:
+        return self._create_child_chunk_request_body
+
+    def chunks(self, chunks: list[ChunkContent]) -> CreateChildChunkRequestBodyBuilder:
+        self._create_child_chunk_request_body.chunks = chunks
+        return self
+
+    def add_chunk(self, content: str, keywords: list[str] | None = None) -> CreateChildChunkRequestBodyBuilder:
+        """Convenience method to add a single chunk."""
+        chunk = ChunkContent(content=content, keywords=keywords)
+        if self._create_child_chunk_request_body.chunks is None:
+            self._create_child_chunk_request_body.chunks = []
+        self._create_child_chunk_request_body.chunks.append(chunk)
+        return self

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

@@ -1,7 +1,11 @@
+"""Create child chunk response model."""
+
 from dify_oapi.core.model.base_response import BaseResponse
 
 from .child_chunk_info import ChildChunkInfo
 
 
 class CreateChildChunkResponse(BaseResponse):
-    data: ChildChunkInfo | None = None
+    """Response model for create child chunk API."""
+
+    data: list[ChildChunkInfo] | None = None

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

@@ -0,0 +1,30 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .create_dataset_request_body import CreateDatasetRequestBody
+
+
+class CreateDatasetRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.request_body: CreateDatasetRequestBody | None = None
+
+    @staticmethod
+    def builder() -> "CreateDatasetRequestBuilder":
+        return CreateDatasetRequestBuilder()
+
+
+class CreateDatasetRequestBuilder:
+    def __init__(self) -> None:
+        create_dataset_request = CreateDatasetRequest()
+        create_dataset_request.http_method = HttpMethod.POST
+        create_dataset_request.uri = "/v1/datasets"
+        self._create_dataset_request = create_dataset_request
+
+    def build(self) -> CreateDatasetRequest:
+        return self._create_dataset_request
+
+    def request_body(self, request_body: CreateDatasetRequestBody) -> "CreateDatasetRequestBuilder":
+        self._create_dataset_request.request_body = request_body
+        self._create_dataset_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

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

@@ -0,0 +1,67 @@
+from pydantic import BaseModel
+
+from .embedding_model_parameters import EmbeddingModelParameters
+from .knowledge_types import DatasetType, IndexingTechnique, Permission
+from .retrieval_model import RetrievalModel
+
+
+class CreateDatasetRequestBody(BaseModel):
+    name: str | None = None
+    description: str | None = None
+    type: DatasetType | None = None
+    indexing_technique: IndexingTechnique | None = None
+    permission: Permission | None = None
+    provider: str | None = None
+    model: str | None = None
+    embedding_model_parameters: EmbeddingModelParameters | None = None
+    retrieval_model: RetrievalModel | None = None
+
+    @staticmethod
+    def builder() -> "CreateDatasetRequestBodyBuilder":
+        return CreateDatasetRequestBodyBuilder()
+
+
+class CreateDatasetRequestBodyBuilder:
+    def __init__(self) -> None:
+        self._create_dataset_request_body = CreateDatasetRequestBody()
+
+    def build(self) -> CreateDatasetRequestBody:
+        return self._create_dataset_request_body
+
+    def name(self, name: str) -> "CreateDatasetRequestBodyBuilder":
+        self._create_dataset_request_body.name = name
+        return self
+
+    def description(self, description: str) -> "CreateDatasetRequestBodyBuilder":
+        self._create_dataset_request_body.description = description
+        return self
+
+    def type(self, type: DatasetType) -> "CreateDatasetRequestBodyBuilder":
+        self._create_dataset_request_body.type = type
+        return self
+
+    def indexing_technique(self, indexing_technique: IndexingTechnique) -> "CreateDatasetRequestBodyBuilder":
+        self._create_dataset_request_body.indexing_technique = indexing_technique
+        return self
+
+    def permission(self, permission: Permission) -> "CreateDatasetRequestBodyBuilder":
+        self._create_dataset_request_body.permission = permission
+        return self
+
+    def provider(self, provider: str) -> "CreateDatasetRequestBodyBuilder":
+        self._create_dataset_request_body.provider = provider
+        return self
+
+    def model(self, model: str) -> "CreateDatasetRequestBodyBuilder":
+        self._create_dataset_request_body.model = model
+        return self
+
+    def embedding_model_parameters(
+        self, embedding_model_parameters: EmbeddingModelParameters
+    ) -> "CreateDatasetRequestBodyBuilder":
+        self._create_dataset_request_body.embedding_model_parameters = embedding_model_parameters
+        return self
+
+    def retrieval_model(self, retrieval_model: RetrievalModel) -> "CreateDatasetRequestBodyBuilder":
+        self._create_dataset_request_body.retrieval_model = retrieval_model
+        return self

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

@@ -0,0 +1,7 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .dataset_info import DatasetInfo
+
+
+class CreateDatasetResponse(DatasetInfo, BaseResponse):
+    pass