dify-oapi2 0.1.0__py3-none-any.whl

dify_oapi/api/knowledge_base/v1/model/segment/delete_request.py

@@ -0,0 +1,40 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class DeleteRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.document_id: str | None = None
+        self.segment_id: str | None = None
+
+    @staticmethod
+    def builder() -> "DeleteRequestBuilder":
+        return DeleteRequestBuilder()
+
+
+class DeleteRequestBuilder:
+    def __init__(self):
+        delete_request = DeleteRequest()
+        delete_request.http_method = HttpMethod.DELETE
+        delete_request.uri = "/v1/datasets/:dataset_id/documents/:document_id/segments/:segment_id"
+        self._delete_request = delete_request
+
+    def build(self) -> DeleteRequest:
+        return self._delete_request
+
+    def dataset_id(self, dataset_id: str) -> "DeleteRequestBuilder":
+        self._delete_request.dataset_id = dataset_id
+        self._delete_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def document_id(self, document_id: str) -> "DeleteRequestBuilder":
+        self._delete_request.document_id = document_id
+        self._delete_request.paths["document_id"] = document_id
+        return self
+
+    def segment_id(self, segment_id: str) -> "DeleteRequestBuilder":
+        self._delete_request.segment_id = segment_id
+        self._delete_request.paths["segment_id"] = segment_id
+        return self

dify_oapi/api/knowledge_base/v1/model/segment/delete_response.py

@@ -0,0 +1,5 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class DeleteResponse(BaseResponse):
+    pass

dify_oapi/api/knowledge_base/v1/model/segment/get_request.py

@@ -0,0 +1,40 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class GetRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.document_id: str | None = None
+        self.segment_id: str | None = None
+
+    @staticmethod
+    def builder() -> "GetRequestBuilder":
+        return GetRequestBuilder()
+
+
+class GetRequestBuilder:
+    def __init__(self):
+        get_request = GetRequest()
+        get_request.http_method = HttpMethod.GET
+        get_request.uri = "/v1/datasets/:dataset_id/documents/:document_id/segments/:segment_id"
+        self._get_request = get_request
+
+    def build(self) -> GetRequest:
+        return self._get_request
+
+    def dataset_id(self, dataset_id: str) -> "GetRequestBuilder":
+        self._get_request.dataset_id = dataset_id
+        self._get_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def document_id(self, document_id: str) -> "GetRequestBuilder":
+        self._get_request.document_id = document_id
+        self._get_request.paths["document_id"] = document_id
+        return self
+
+    def segment_id(self, segment_id: str) -> "GetRequestBuilder":
+        self._get_request.segment_id = segment_id
+        self._get_request.paths["segment_id"] = segment_id
+        return self

dify_oapi/api/knowledge_base/v1/model/segment/get_response.py

@@ -0,0 +1,8 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .segment_info import SegmentInfo
+
+
+class GetResponse(BaseResponse):
+    data: SegmentInfo | None = None
+    doc_form: str | None = None

dify_oapi/api/knowledge_base/v1/model/segment/list_child_chunks_request.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class ListChildChunksRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.document_id: str | None = None
+        self.segment_id: str | None = None
+
+    @staticmethod
+    def builder() -> ListChildChunksRequestBuilder:
+        return ListChildChunksRequestBuilder()
+
+
+class ListChildChunksRequestBuilder:
+    def __init__(self):
+        list_child_chunks_request = ListChildChunksRequest()
+        list_child_chunks_request.http_method = HttpMethod.GET
+        list_child_chunks_request.uri = (
+            "/v1/datasets/:dataset_id/documents/:document_id/segments/:segment_id/child_chunks"
+        )
+        self._list_child_chunks_request = list_child_chunks_request
+
+    def build(self) -> ListChildChunksRequest:
+        return self._list_child_chunks_request
+
+    def dataset_id(self, dataset_id: str) -> ListChildChunksRequestBuilder:
+        self._list_child_chunks_request.dataset_id = dataset_id
+        self._list_child_chunks_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def document_id(self, document_id: str) -> ListChildChunksRequestBuilder:
+        self._list_child_chunks_request.document_id = document_id
+        self._list_child_chunks_request.paths["document_id"] = document_id
+        return self
+
+    def segment_id(self, segment_id: str) -> ListChildChunksRequestBuilder:
+        self._list_child_chunks_request.segment_id = segment_id
+        self._list_child_chunks_request.paths["segment_id"] = segment_id
+        return self
+
+    def keyword(self, keyword: str) -> ListChildChunksRequestBuilder:
+        self._list_child_chunks_request.add_query("keyword", keyword)
+        return self
+
+    def page(self, page: int) -> ListChildChunksRequestBuilder:
+        self._list_child_chunks_request.add_query("page", page)
+        return self
+
+    def limit(self, limit: int) -> ListChildChunksRequestBuilder:
+        self._list_child_chunks_request.add_query("limit", limit)
+        return self

dify_oapi/api/knowledge_base/v1/model/segment/list_child_chunks_response.py

@@ -0,0 +1,11 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .child_chunk_info import ChildChunkInfo
+
+
+class ListChildChunksResponse(BaseResponse):
+    data: list[ChildChunkInfo] | None = None
+    total: int | None = None
+    total_pages: int | None = None
+    page: int | None = None
+    limit: int | None = None

dify_oapi/api/knowledge_base/v1/model/segment/list_request.py

@@ -0,0 +1,50 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class ListRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.document_id: str | None = None
+
+    @staticmethod
+    def builder() -> "ListRequestBuilder":
+        return ListRequestBuilder()
+
+
+class ListRequestBuilder:
+    def __init__(self):
+        list_request = ListRequest()
+        list_request.http_method = HttpMethod.GET
+        list_request.uri = "/v1/datasets/:dataset_id/documents/:document_id/segments"
+        self._list_request = list_request
+
+    def build(self) -> ListRequest:
+        return self._list_request
+
+    def dataset_id(self, dataset_id: str) -> "ListRequestBuilder":
+        self._list_request.dataset_id = dataset_id
+        self._list_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def document_id(self, document_id: str) -> "ListRequestBuilder":
+        self._list_request.document_id = document_id
+        self._list_request.paths["document_id"] = document_id
+        return self
+
+    def keyword(self, keyword: str) -> "ListRequestBuilder":
+        self._list_request.add_query("keyword", keyword)
+        return self
+
+    def status(self, status: str) -> "ListRequestBuilder":
+        self._list_request.add_query("status", status)
+        return self
+
+    def page(self, page: int) -> "ListRequestBuilder":
+        self._list_request.add_query("page", page)
+        return self
+
+    def limit(self, limit: int) -> "ListRequestBuilder":
+        self._list_request.add_query("limit", limit)
+        return self

dify_oapi/api/knowledge_base/v1/model/segment/list_response.py

@@ -0,0 +1,12 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .segment_info import SegmentInfo
+
+
+class ListResponse(BaseResponse):
+    data: list[SegmentInfo] | None = None
+    doc_form: str | None = None
+    has_more: bool | None = None
+    limit: int | None = None
+    total: int | None = None
+    page: int | None = None

dify_oapi/api/knowledge_base/v1/model/segment/segment_data.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class SegmentData(BaseModel):
+    content: str | None = None
+    answer: str | None = None
+    keywords: list[str] | None = None
+    enabled: bool | None = None
+    regenerate_child_chunks: bool | None = None
+
+    @staticmethod
+    def builder() -> SegmentDataBuilder:
+        return SegmentDataBuilder()
+
+
+class SegmentDataBuilder:
+    def __init__(self):
+        self._segment_data = SegmentData()
+
+    def build(self) -> SegmentData:
+        return self._segment_data
+
+    def content(self, content: str) -> SegmentDataBuilder:
+        self._segment_data.content = content
+        return self
+
+    def answer(self, answer: str) -> SegmentDataBuilder:
+        self._segment_data.answer = answer
+        return self
+
+    def keywords(self, keywords: list[str]) -> SegmentDataBuilder:
+        self._segment_data.keywords = keywords
+        return self
+
+    def enabled(self, enabled: bool) -> SegmentDataBuilder:
+        self._segment_data.enabled = enabled
+        return self
+
+    def regenerate_child_chunks(self, regenerate_child_chunks: bool) -> SegmentDataBuilder:
+        self._segment_data.regenerate_child_chunks = regenerate_child_chunks
+        return self

dify_oapi/api/knowledge_base/v1/model/segment/segment_info.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class SegmentInfo(BaseModel):
+    id: str | None = None
+    position: int | None = None
+    document_id: str | None = None
+    content: str | None = None
+    answer: str | None = None
+    word_count: int | None = None
+    tokens: int | None = None
+    keywords: list[str] | None = None
+    index_node_id: str | None = None
+    index_node_hash: str | None = None
+    hit_count: int | None = None
+    enabled: bool | None = None
+    disabled_at: int | None = None
+    disabled_by: str | None = None
+    status: str | None = None
+    created_by: str | None = None
+    created_at: int | None = None
+    indexing_at: int | None = None
+    completed_at: int | None = None
+    error: str | None = None
+    stopped_at: int | None = None
+
+    @staticmethod
+    def builder() -> SegmentInfoBuilder:
+        return SegmentInfoBuilder()
+
+
+class SegmentInfoBuilder:
+    def __init__(self):
+        self._segment_info = SegmentInfo()
+
+    def build(self) -> SegmentInfo:
+        return self._segment_info
+
+    def id(self, id: str) -> SegmentInfoBuilder:
+        self._segment_info.id = id
+        return self
+
+    def position(self, position: int) -> SegmentInfoBuilder:
+        self._segment_info.position = position
+        return self
+
+    def document_id(self, document_id: str) -> SegmentInfoBuilder:
+        self._segment_info.document_id = document_id
+        return self
+
+    def content(self, content: str) -> SegmentInfoBuilder:
+        self._segment_info.content = content
+        return self
+
+    def answer(self, answer: str) -> SegmentInfoBuilder:
+        self._segment_info.answer = answer
+        return self
+
+    def word_count(self, word_count: int) -> SegmentInfoBuilder:
+        self._segment_info.word_count = word_count
+        return self
+
+    def tokens(self, tokens: int) -> SegmentInfoBuilder:
+        self._segment_info.tokens = tokens
+        return self
+
+    def keywords(self, keywords: list[str]) -> SegmentInfoBuilder:
+        self._segment_info.keywords = keywords
+        return self
+
+    def index_node_id(self, index_node_id: str) -> SegmentInfoBuilder:
+        self._segment_info.index_node_id = index_node_id
+        return self
+
+    def index_node_hash(self, index_node_hash: str) -> SegmentInfoBuilder:
+        self._segment_info.index_node_hash = index_node_hash
+        return self
+
+    def hit_count(self, hit_count: int) -> SegmentInfoBuilder:
+        self._segment_info.hit_count = hit_count
+        return self
+
+    def enabled(self, enabled: bool) -> SegmentInfoBuilder:
+        self._segment_info.enabled = enabled
+        return self
+
+    def disabled_at(self, disabled_at: int) -> SegmentInfoBuilder:
+        self._segment_info.disabled_at = disabled_at
+        return self
+
+    def disabled_by(self, disabled_by: str) -> SegmentInfoBuilder:
+        self._segment_info.disabled_by = disabled_by
+        return self
+
+    def status(self, status: str) -> SegmentInfoBuilder:
+        self._segment_info.status = status
+        return self
+
+    def created_by(self, created_by: str) -> SegmentInfoBuilder:
+        self._segment_info.created_by = created_by
+        return self
+
+    def created_at(self, created_at: int) -> SegmentInfoBuilder:
+        self._segment_info.created_at = created_at
+        return self
+
+    def indexing_at(self, indexing_at: int) -> SegmentInfoBuilder:
+        self._segment_info.indexing_at = indexing_at
+        return self
+
+    def completed_at(self, completed_at: int) -> SegmentInfoBuilder:
+        self._segment_info.completed_at = completed_at
+        return self
+
+    def error(self, error: str) -> SegmentInfoBuilder:
+        self._segment_info.error = error
+        return self
+
+    def stopped_at(self, stopped_at: int) -> SegmentInfoBuilder:
+        self._segment_info.stopped_at = stopped_at
+        return self

dify_oapi/api/knowledge_base/v1/model/segment/update_child_chunk_request.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .update_child_chunk_request_body import UpdateChildChunkRequestBody
+
+
+class UpdateChildChunkRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.document_id: str | None = None
+        self.segment_id: str | None = None
+        self.child_chunk_id: str | None = None
+        self.request_body: UpdateChildChunkRequestBody | None = None
+
+    @staticmethod
+    def builder() -> UpdateChildChunkRequestBuilder:
+        return UpdateChildChunkRequestBuilder()
+
+
+class UpdateChildChunkRequestBuilder:
+    def __init__(self):
+        update_child_chunk_request = UpdateChildChunkRequest()
+        update_child_chunk_request.http_method = HttpMethod.PATCH
+        update_child_chunk_request.uri = (
+            "/v1/datasets/:dataset_id/documents/:document_id/segments/:segment_id/child_chunks/:child_chunk_id"
+        )
+        self._update_child_chunk_request = update_child_chunk_request
+
+    def build(self) -> UpdateChildChunkRequest:
+        return self._update_child_chunk_request
+
+    def dataset_id(self, dataset_id: str) -> UpdateChildChunkRequestBuilder:
+        self._update_child_chunk_request.dataset_id = dataset_id
+        self._update_child_chunk_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def document_id(self, document_id: str) -> UpdateChildChunkRequestBuilder:
+        self._update_child_chunk_request.document_id = document_id
+        self._update_child_chunk_request.paths["document_id"] = document_id
+        return self
+
+    def segment_id(self, segment_id: str) -> UpdateChildChunkRequestBuilder:
+        self._update_child_chunk_request.segment_id = segment_id
+        self._update_child_chunk_request.paths["segment_id"] = segment_id
+        return self
+
+    def child_chunk_id(self, child_chunk_id: str) -> UpdateChildChunkRequestBuilder:
+        self._update_child_chunk_request.child_chunk_id = child_chunk_id
+        self._update_child_chunk_request.paths["child_chunk_id"] = child_chunk_id
+        return self
+
+    def request_body(self, request_body: UpdateChildChunkRequestBody) -> UpdateChildChunkRequestBuilder:
+        self._update_child_chunk_request.request_body = request_body
+        self._update_child_chunk_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

dify_oapi/api/knowledge_base/v1/model/segment/update_child_chunk_request_body.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class UpdateChildChunkRequestBody(BaseModel):
+    content: str | None = None
+
+    @staticmethod
+    def builder() -> UpdateChildChunkRequestBodyBuilder:
+        return UpdateChildChunkRequestBodyBuilder()
+
+
+class UpdateChildChunkRequestBodyBuilder:
+    def __init__(self):
+        self._update_child_chunk_request_body = UpdateChildChunkRequestBody()
+
+    def build(self) -> UpdateChildChunkRequestBody:
+        return self._update_child_chunk_request_body
+
+    def content(self, content: str) -> UpdateChildChunkRequestBodyBuilder:
+        self._update_child_chunk_request_body.content = content
+        return self

dify_oapi/api/knowledge_base/v1/model/segment/update_child_chunk_response.py

@@ -0,0 +1,7 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .child_chunk_info import ChildChunkInfo
+
+
+class UpdateChildChunkResponse(BaseResponse):
+    data: ChildChunkInfo | None = None

dify_oapi/api/knowledge_base/v1/model/segment/update_request.py

@@ -0,0 +1,48 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .update_request_body import UpdateRequestBody
+
+
+class UpdateRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.document_id: str | None = None
+        self.segment_id: str | None = None
+        self.request_body: UpdateRequestBody | None = None
+
+    @staticmethod
+    def builder() -> "UpdateRequestBuilder":
+        return UpdateRequestBuilder()
+
+
+class UpdateRequestBuilder:
+    def __init__(self):
+        update_request = UpdateRequest()
+        update_request.http_method = HttpMethod.POST
+        update_request.uri = "/v1/datasets/:dataset_id/documents/:document_id/segments/:segment_id"
+        self._update_request = update_request
+
+    def build(self) -> UpdateRequest:
+        return self._update_request
+
+    def dataset_id(self, dataset_id: str) -> "UpdateRequestBuilder":
+        self._update_request.dataset_id = dataset_id
+        self._update_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def document_id(self, document_id: str) -> "UpdateRequestBuilder":
+        self._update_request.document_id = document_id
+        self._update_request.paths["document_id"] = document_id
+        return self
+
+    def segment_id(self, segment_id: str) -> "UpdateRequestBuilder":
+        self._update_request.segment_id = segment_id
+        self._update_request.paths["segment_id"] = segment_id
+        return self
+
+    def request_body(self, request_body: UpdateRequestBody) -> "UpdateRequestBuilder":
+        self._update_request.request_body = request_body
+        self._update_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

dify_oapi/api/knowledge_base/v1/model/segment/update_request_body.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .segment_data import SegmentData
+
+
+class UpdateRequestBody(BaseModel):
+    segment: SegmentData | None = None
+
+    @staticmethod
+    def builder() -> UpdateRequestBodyBuilder:
+        return UpdateRequestBodyBuilder()
+
+
+class UpdateRequestBodyBuilder:
+    def __init__(self):
+        self._update_request_body = UpdateRequestBody()
+
+    def build(self) -> UpdateRequestBody:
+        return self._update_request_body
+
+    def segment(self, segment: SegmentData) -> UpdateRequestBodyBuilder:
+        self._update_request_body.segment = segment
+        return self

dify_oapi/api/knowledge_base/v1/model/segment/update_response.py

@@ -0,0 +1,8 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .segment_info import SegmentInfo
+
+
+class UpdateResponse(BaseResponse):
+    data: SegmentInfo | None = None
+    doc_form: str | None = None

dify_oapi/api/knowledge_base/v1/model/tag/__init__.py

@@ -0,0 +1,41 @@
+from .bind_request import BindRequest
+from .bind_request_body import BindRequestBody
+from .bind_response import BindResponse
+from .create_request import CreateRequest
+from .create_request_body import CreateRequestBody
+from .create_response import CreateResponse
+from .delete_request import DeleteRequest
+from .delete_request_body import DeleteRequestBody
+from .delete_response import DeleteResponse
+from .list_request import ListRequest
+from .list_response import ListResponse
+from .query_bound_request import QueryBoundRequest
+from .query_bound_response import QueryBoundResponse
+from .unbind_request import UnbindRequest
+from .unbind_request_body import UnbindRequestBody
+from .unbind_response import UnbindResponse
+from .update_request import UpdateRequest
+from .update_request_body import UpdateRequestBody
+from .update_response import UpdateResponse
+
+__all__ = [
+    "BindRequest",
+    "BindRequestBody",
+    "BindResponse",
+    "CreateRequest",
+    "CreateRequestBody",
+    "CreateResponse",
+    "DeleteRequest",
+    "DeleteRequestBody",
+    "DeleteResponse",
+    "ListRequest",
+    "ListResponse",
+    "QueryBoundRequest",
+    "QueryBoundResponse",
+    "UnbindRequest",
+    "UnbindRequestBody",
+    "UnbindResponse",
+    "UpdateRequest",
+    "UpdateRequestBody",
+    "UpdateResponse",
+]

dify_oapi/api/knowledge_base/v1/model/tag/bind_request.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .bind_request_body import BindRequestBody
+
+
+class BindRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.request_body: BindRequestBody | None = None
+
+    @staticmethod
+    def builder() -> BindRequestBuilder:
+        return BindRequestBuilder()
+
+
+class BindRequestBuilder:
+    def __init__(self):
+        bind_request = BindRequest()
+        bind_request.http_method = HttpMethod.POST
+        bind_request.uri = "/v1/datasets/tags/binding"
+        self._request = bind_request
+
+    def build(self) -> BindRequest:
+        return self._request
+
+    def request_body(self, request_body: BindRequestBody) -> BindRequestBuilder:
+        self._request.request_body = request_body
+        self._request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

dify_oapi/api/knowledge_base/v1/model/tag/bind_request_body.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class BindRequestBody(BaseModel):
+    tag_ids: list[str] = []
+    target_id: str = ""
+
+    @staticmethod
+    def builder() -> BindRequestBodyBuilder:
+        return BindRequestBodyBuilder()
+
+
+class BindRequestBodyBuilder:
+    def __init__(self):
+        bind_request_body = BindRequestBody()
+        self._request_body = bind_request_body
+
+    def build(self) -> BindRequestBody:
+        return self._request_body
+
+    def tag_ids(self, tag_ids: list[str]) -> BindRequestBodyBuilder:
+        self._request_body.tag_ids = tag_ids
+        return self
+
+    def target_id(self, target_id: str) -> BindRequestBodyBuilder:
+        self._request_body.target_id = target_id
+        return self