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

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/bind_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 BindResponse(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

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

@@ -0,0 +1,55 @@
+"""Create document by file request model."""
+
+from __future__ import annotations
+
+import json
+from io import BytesIO
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .create_document_by_file_request_body import CreateDocumentByFileRequestBody
+
+
+class CreateDocumentByFileRequest(BaseRequest):
+    """Request model for create document by file API."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.request_body: CreateDocumentByFileRequestBody | None = None
+        self.file: BytesIO | None = None
+
+    @staticmethod
+    def builder() -> CreateDocumentByFileRequestBuilder:
+        return CreateDocumentByFileRequestBuilder()
+
+
+class CreateDocumentByFileRequestBuilder:
+    """Builder for CreateDocumentByFileRequest."""
+
+    def __init__(self) -> None:
+        create_document_by_file_request = CreateDocumentByFileRequest()
+        create_document_by_file_request.http_method = HttpMethod.POST
+        create_document_by_file_request.uri = "/v1/datasets/:dataset_id/document/create-by-file"
+        self._create_document_by_file_request = create_document_by_file_request
+
+    def build(self) -> CreateDocumentByFileRequest:
+        return self._create_document_by_file_request
+
+    def dataset_id(self, dataset_id: str) -> CreateDocumentByFileRequestBuilder:
+        self._create_document_by_file_request.dataset_id = dataset_id
+        self._create_document_by_file_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def request_body(self, request_body: CreateDocumentByFileRequestBody) -> CreateDocumentByFileRequestBuilder:
+        self._create_document_by_file_request.request_body = request_body
+        data_dict = request_body.model_dump(exclude_none=True, mode="json")
+        self._create_document_by_file_request.body = {"data": json.dumps(data_dict)}
+        return self
+
+    def file(self, file: BytesIO, file_name: str | None = None) -> CreateDocumentByFileRequestBuilder:
+        self._create_document_by_file_request.file = file
+        file_name = file_name or "upload"
+        self._create_document_by_file_request.files = {"file": (file_name, file)}
+        return self

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

@@ -0,0 +1,73 @@
+"""Create document by file request body model."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .knowledge_types import DocumentForm, IndexingTechnique
+from .process_rule import ProcessRule
+from .retrieval_model import RetrievalModel
+
+
+class CreateDocumentByFileRequestBody(BaseModel):
+    """Request body model for create document by file API."""
+
+    name: str | None = None
+    original_document_id: str | None = None  # UUID for re-upload/modify
+    indexing_technique: IndexingTechnique | None = None
+    doc_form: DocumentForm | None = None
+    doc_language: str | None = None
+    process_rule: ProcessRule | None = None
+    retrieval_model: RetrievalModel | None = None
+    embedding_model: str | None = None
+    embedding_model_provider: str | None = None
+
+    @staticmethod
+    def builder() -> CreateDocumentByFileRequestBodyBuilder:
+        return CreateDocumentByFileRequestBodyBuilder()
+
+
+class CreateDocumentByFileRequestBodyBuilder:
+    """Builder for CreateDocumentByFileRequestBody."""
+
+    def __init__(self) -> None:
+        self._create_document_by_file_request_body = CreateDocumentByFileRequestBody()
+
+    def build(self) -> CreateDocumentByFileRequestBody:
+        return self._create_document_by_file_request_body
+
+    def name(self, name: str) -> CreateDocumentByFileRequestBodyBuilder:
+        self._create_document_by_file_request_body.name = name
+        return self
+
+    def indexing_technique(self, indexing_technique: IndexingTechnique) -> CreateDocumentByFileRequestBodyBuilder:
+        self._create_document_by_file_request_body.indexing_technique = indexing_technique
+        return self
+
+    def process_rule(self, process_rule: ProcessRule) -> CreateDocumentByFileRequestBodyBuilder:
+        self._create_document_by_file_request_body.process_rule = process_rule
+        return self
+
+    def original_document_id(self, original_document_id: str) -> CreateDocumentByFileRequestBodyBuilder:
+        self._create_document_by_file_request_body.original_document_id = original_document_id
+        return self
+
+    def doc_form(self, doc_form: DocumentForm) -> CreateDocumentByFileRequestBodyBuilder:
+        self._create_document_by_file_request_body.doc_form = doc_form
+        return self
+
+    def doc_language(self, doc_language: str) -> CreateDocumentByFileRequestBodyBuilder:
+        self._create_document_by_file_request_body.doc_language = doc_language
+        return self
+
+    def retrieval_model(self, retrieval_model: RetrievalModel) -> CreateDocumentByFileRequestBodyBuilder:
+        self._create_document_by_file_request_body.retrieval_model = retrieval_model
+        return self
+
+    def embedding_model(self, embedding_model: str) -> CreateDocumentByFileRequestBodyBuilder:
+        self._create_document_by_file_request_body.embedding_model = embedding_model
+        return self
+
+    def embedding_model_provider(self, embedding_model_provider: str) -> CreateDocumentByFileRequestBodyBuilder:
+        self._create_document_by_file_request_body.embedding_model_provider = embedding_model_provider
+        return self

dify_oapi/api/{knowledge_base/v1/model/document/create_by_file_response.py → knowledge/v1/model/create_document_by_file_response.py}

@@ -5,7 +5,7 @@ from dify_oapi.core.model.base_response import BaseResponse
 from .document_info import DocumentInfo
 
 
-class CreateByFileResponse(BaseResponse):
+class CreateDocumentByFileResponse(BaseResponse):
     """Response model for create document by file API."""
 
     document: DocumentInfo | None = None

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

@@ -0,0 +1,44 @@
+"""Create document by text request model."""
+
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .create_document_by_text_request_body import CreateDocumentByTextRequestBody
+
+
+class CreateDocumentByTextRequest(BaseRequest):
+    """Request model for create document by text API."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.request_body: CreateDocumentByTextRequestBody | None = None
+
+    @staticmethod
+    def builder() -> CreateDocumentByTextRequestBuilder:
+        return CreateDocumentByTextRequestBuilder()
+
+
+class CreateDocumentByTextRequestBuilder:
+    """Builder for CreateDocumentByTextRequest."""
+
+    def __init__(self) -> None:
+        create_document_by_text_request = CreateDocumentByTextRequest()
+        create_document_by_text_request.http_method = HttpMethod.POST
+        create_document_by_text_request.uri = "/v1/datasets/:dataset_id/document/create-by-text"
+        self._create_document_by_text_request = create_document_by_text_request
+
+    def build(self) -> CreateDocumentByTextRequest:
+        return self._create_document_by_text_request
+
+    def dataset_id(self, dataset_id: str) -> CreateDocumentByTextRequestBuilder:
+        self._create_document_by_text_request.dataset_id = dataset_id
+        self._create_document_by_text_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def request_body(self, request_body: CreateDocumentByTextRequestBody) -> CreateDocumentByTextRequestBuilder:
+        self._create_document_by_text_request.request_body = request_body
+        self._create_document_by_text_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self