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

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

@@ -0,0 +1,29 @@
+"""Update document status request body model."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class UpdateDocumentStatusRequestBody(BaseModel):
+    """Request body model for update document status API."""
+
+    document_ids: list[str] | None = None
+
+    @staticmethod
+    def builder() -> UpdateDocumentStatusRequestBodyBuilder:
+        return UpdateDocumentStatusRequestBodyBuilder()
+
+
+class UpdateDocumentStatusRequestBodyBuilder:
+    """Builder for UpdateDocumentStatusRequestBody."""
+
+    def __init__(self) -> None:
+        self._update_document_status_request_body = UpdateDocumentStatusRequestBody()
+
+    def build(self) -> UpdateDocumentStatusRequestBody:
+        return self._update_document_status_request_body
+
+    def document_ids(self, document_ids: list[str]) -> UpdateDocumentStatusRequestBodyBuilder:
+        self._update_document_status_request_body.document_ids = document_ids
+        return self

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

@@ -0,0 +1,9 @@
+"""Update document status response model."""
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class UpdateDocumentStatusResponse(BaseResponse):
+    """Response model for update document status API."""
+
+    result: str | None = None

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

@@ -0,0 +1,56 @@
+"""Update segment request model."""
+
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .update_segment_request_body import UpdateSegmentRequestBody
+
+
+class UpdateSegmentRequest(BaseRequest):
+    """Request model for update segment API."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.document_id: str | None = None
+        self.segment_id: str | None = None
+        self.request_body: UpdateSegmentRequestBody | None = None
+
+    @staticmethod
+    def builder() -> UpdateSegmentRequestBuilder:
+        return UpdateSegmentRequestBuilder()
+
+
+class UpdateSegmentRequestBuilder:
+    """Builder for UpdateSegmentRequest."""
+
+    def __init__(self) -> None:
+        update_segment_request = UpdateSegmentRequest()
+        update_segment_request.http_method = HttpMethod.POST
+        update_segment_request.uri = "/v1/datasets/:dataset_id/documents/:document_id/segments/:segment_id"
+        self._update_segment_request = update_segment_request
+
+    def build(self) -> UpdateSegmentRequest:
+        return self._update_segment_request
+
+    def dataset_id(self, dataset_id: str) -> UpdateSegmentRequestBuilder:
+        self._update_segment_request.dataset_id = dataset_id
+        self._update_segment_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def document_id(self, document_id: str) -> UpdateSegmentRequestBuilder:
+        self._update_segment_request.document_id = document_id
+        self._update_segment_request.paths["document_id"] = document_id
+        return self
+
+    def segment_id(self, segment_id: str) -> UpdateSegmentRequestBuilder:
+        self._update_segment_request.segment_id = segment_id
+        self._update_segment_request.paths["segment_id"] = segment_id
+        return self
+
+    def request_body(self, request_body: UpdateSegmentRequestBody) -> UpdateSegmentRequestBuilder:
+        self._update_segment_request.request_body = request_body
+        self._update_segment_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

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

@@ -0,0 +1,31 @@
+"""Update segment request body model."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .segment_content import SegmentContent
+
+
+class UpdateSegmentRequestBody(BaseModel):
+    """Request body model for update segment API."""
+
+    segment: SegmentContent | None = None
+
+    @staticmethod
+    def builder() -> UpdateSegmentRequestBodyBuilder:
+        return UpdateSegmentRequestBodyBuilder()
+
+
+class UpdateSegmentRequestBodyBuilder:
+    """Builder for UpdateSegmentRequestBody."""
+
+    def __init__(self) -> None:
+        self._update_segment_request_body = UpdateSegmentRequestBody()
+
+    def build(self) -> UpdateSegmentRequestBody:
+        return self._update_segment_request_body
+
+    def segment(self, segment: SegmentContent) -> UpdateSegmentRequestBodyBuilder:
+        self._update_segment_request_body.segment = segment
+        return self

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

@@ -1,8 +1,12 @@
+"""Update segment response model."""
+
 from dify_oapi.core.model.base_response import BaseResponse
 
 from .segment_info import SegmentInfo
 
 
-class UpdateResponse(BaseResponse):
+class UpdateSegmentResponse(BaseResponse):
+    """Response model for update segment API."""
+
     data: SegmentInfo | None = None
     doc_form: str | None = None

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

@@ -0,0 +1,30 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .update_tag_request_body import UpdateTagRequestBody
+
+
+class UpdateTagRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.request_body: UpdateTagRequestBody | None = None
+
+    @staticmethod
+    def builder() -> "UpdateTagRequestBuilder":
+        return UpdateTagRequestBuilder()
+
+
+class UpdateTagRequestBuilder:
+    def __init__(self):
+        update_tag_request = UpdateTagRequest()
+        update_tag_request.http_method = HttpMethod.PATCH
+        update_tag_request.uri = "/v1/datasets/tags"
+        self._update_tag_request = update_tag_request
+
+    def build(self) -> UpdateTagRequest:
+        return self._update_tag_request
+
+    def request_body(self, request_body: UpdateTagRequestBody) -> "UpdateTagRequestBuilder":
+        self._update_tag_request.request_body = request_body
+        self._update_tag_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

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

@@ -0,0 +1,26 @@
+from pydantic import BaseModel
+
+
+class UpdateTagRequestBody(BaseModel):
+    tag_id: str | None = None
+    name: str | None = None
+
+    @staticmethod
+    def builder() -> "UpdateTagRequestBodyBuilder":
+        return UpdateTagRequestBodyBuilder()
+
+
+class UpdateTagRequestBodyBuilder:
+    def __init__(self):
+        self._update_tag_request_body = UpdateTagRequestBody()
+
+    def build(self) -> UpdateTagRequestBody:
+        return self._update_tag_request_body
+
+    def tag_id(self, tag_id: str) -> "UpdateTagRequestBodyBuilder":
+        self._update_tag_request_body.tag_id = tag_id
+        return self
+
+    def name(self, name: str) -> "UpdateTagRequestBodyBuilder":
+        self._update_tag_request_body.name = name
+        return self

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

@@ -0,0 +1,7 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .tag_info import TagInfo
+
+
+class UpdateTagResponse(TagInfo, BaseResponse):
+    pass

dify_oapi/api/knowledge/v1/resource/__init__.py

@@ -0,0 +1,8 @@
+from .chunk import Chunk
+from .dataset import Dataset
+from .document import Document
+from .model import Model
+from .segment import Segment
+from .tag import Tag
+
+__all__ = ["Chunk", "Dataset", "Document", "Model", "Segment", "Tag"]

dify_oapi/api/knowledge/v1/resource/chunk.py

@@ -0,0 +1,55 @@
+from dify_oapi.core.http.transport import ATransport, Transport
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.request_option import RequestOption
+
+from ..model.create_child_chunk_request import CreateChildChunkRequest
+from ..model.create_child_chunk_response import CreateChildChunkResponse
+from ..model.delete_child_chunk_request import DeleteChildChunkRequest
+from ..model.delete_child_chunk_response import DeleteChildChunkResponse
+from ..model.list_child_chunks_request import ListChildChunksRequest
+from ..model.list_child_chunks_response import ListChildChunksResponse
+from ..model.update_child_chunk_request import UpdateChildChunkRequest
+from ..model.update_child_chunk_response import UpdateChildChunkResponse
+
+
+class Chunk:
+    def __init__(self, config: Config):
+        self.config = config
+
+    def list(self, request: ListChildChunksRequest, request_option: RequestOption) -> ListChildChunksResponse:
+        return Transport.execute(self.config, request, unmarshal_as=ListChildChunksResponse, option=request_option)
+
+    async def alist(self, request: ListChildChunksRequest, request_option: RequestOption) -> ListChildChunksResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=ListChildChunksResponse, option=request_option
+        )
+
+    def create(self, request: CreateChildChunkRequest, request_option: RequestOption) -> CreateChildChunkResponse:
+        return Transport.execute(self.config, request, unmarshal_as=CreateChildChunkResponse, option=request_option)
+
+    async def acreate(
+        self, request: CreateChildChunkRequest, request_option: RequestOption
+    ) -> CreateChildChunkResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=CreateChildChunkResponse, option=request_option
+        )
+
+    def update(self, request: UpdateChildChunkRequest, request_option: RequestOption) -> UpdateChildChunkResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateChildChunkResponse, option=request_option)
+
+    async def aupdate(
+        self, request: UpdateChildChunkRequest, request_option: RequestOption
+    ) -> UpdateChildChunkResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=UpdateChildChunkResponse, option=request_option
+        )
+
+    def delete(self, request: DeleteChildChunkRequest, request_option: RequestOption) -> DeleteChildChunkResponse:
+        return Transport.execute(self.config, request, unmarshal_as=DeleteChildChunkResponse, option=request_option)
+
+    async def adelete(
+        self, request: DeleteChildChunkRequest, request_option: RequestOption
+    ) -> DeleteChildChunkResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=DeleteChildChunkResponse, option=request_option
+        )

dify_oapi/api/knowledge/v1/resource/dataset.py

@@ -0,0 +1,69 @@
+from dify_oapi.core.http.transport import ATransport, Transport
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.request_option import RequestOption
+
+from ..model.create_dataset_request import CreateDatasetRequest
+from ..model.create_dataset_response import CreateDatasetResponse
+from ..model.delete_dataset_request import DeleteDatasetRequest
+from ..model.delete_dataset_response import DeleteDatasetResponse
+from ..model.get_dataset_request import GetDatasetRequest
+from ..model.get_dataset_response import GetDatasetResponse
+from ..model.list_datasets_request import ListDatasetsRequest
+from ..model.list_datasets_response import ListDatasetsResponse
+from ..model.retrieve_from_dataset_request import RetrieveFromDatasetRequest
+from ..model.retrieve_from_dataset_response import RetrieveFromDatasetResponse
+from ..model.update_dataset_request import UpdateDatasetRequest
+from ..model.update_dataset_response import UpdateDatasetResponse
+
+
+class Dataset:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def create(self, request: CreateDatasetRequest, request_option: RequestOption) -> CreateDatasetResponse:
+        return Transport.execute(self.config, request, unmarshal_as=CreateDatasetResponse, option=request_option)
+
+    async def acreate(self, request: CreateDatasetRequest, request_option: RequestOption) -> CreateDatasetResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=CreateDatasetResponse, option=request_option
+        )
+
+    def list(self, request: ListDatasetsRequest, request_option: RequestOption) -> ListDatasetsResponse:
+        return Transport.execute(self.config, request, unmarshal_as=ListDatasetsResponse, option=request_option)
+
+    async def alist(self, request: ListDatasetsRequest, request_option: RequestOption) -> ListDatasetsResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=ListDatasetsResponse, option=request_option)
+
+    def get(self, request: GetDatasetRequest, request_option: RequestOption) -> GetDatasetResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetDatasetResponse, option=request_option)
+
+    async def aget(self, request: GetDatasetRequest, request_option: RequestOption) -> GetDatasetResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=GetDatasetResponse, option=request_option)
+
+    def update(self, request: UpdateDatasetRequest, request_option: RequestOption) -> UpdateDatasetResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateDatasetResponse, option=request_option)
+
+    async def aupdate(self, request: UpdateDatasetRequest, request_option: RequestOption) -> UpdateDatasetResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=UpdateDatasetResponse, option=request_option
+        )
+
+    def delete(self, request: DeleteDatasetRequest, request_option: RequestOption) -> DeleteDatasetResponse:
+        return Transport.execute(self.config, request, unmarshal_as=DeleteDatasetResponse, option=request_option)
+
+    async def adelete(self, request: DeleteDatasetRequest, request_option: RequestOption) -> DeleteDatasetResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=DeleteDatasetResponse, option=request_option
+        )
+
+    def retrieve(
+        self, request: RetrieveFromDatasetRequest, request_option: RequestOption
+    ) -> RetrieveFromDatasetResponse:
+        return Transport.execute(self.config, request, unmarshal_as=RetrieveFromDatasetResponse, option=request_option)
+
+    async def aretrieve(
+        self, request: RetrieveFromDatasetRequest, request_option: RequestOption
+    ) -> RetrieveFromDatasetResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=RetrieveFromDatasetResponse, option=request_option
+        )

dify_oapi/api/knowledge/v1/resource/document.py

@@ -0,0 +1,135 @@
+from dify_oapi.core.http.transport import ATransport, Transport
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.request_option import RequestOption
+
+from ..model.create_document_by_file_request import CreateDocumentByFileRequest
+from ..model.create_document_by_file_response import CreateDocumentByFileResponse
+from ..model.create_document_by_text_request import CreateDocumentByTextRequest
+from ..model.create_document_by_text_response import CreateDocumentByTextResponse
+from ..model.delete_document_request import DeleteDocumentRequest
+from ..model.delete_document_response import DeleteDocumentResponse
+from ..model.get_batch_indexing_status_request import GetBatchIndexingStatusRequest
+from ..model.get_batch_indexing_status_response import GetBatchIndexingStatusResponse
+from ..model.get_document_request import GetDocumentRequest
+from ..model.get_document_response import GetDocumentResponse
+from ..model.get_upload_file_info_request import GetUploadFileInfoRequest
+from ..model.get_upload_file_info_response import GetUploadFileInfoResponse
+from ..model.list_documents_request import ListDocumentsRequest
+from ..model.list_documents_response import ListDocumentsResponse
+from ..model.update_document_by_file_request import UpdateDocumentByFileRequest
+from ..model.update_document_by_file_response import UpdateDocumentByFileResponse
+from ..model.update_document_by_text_request import UpdateDocumentByTextRequest
+from ..model.update_document_by_text_response import UpdateDocumentByTextResponse
+from ..model.update_document_status_request import UpdateDocumentStatusRequest
+from ..model.update_document_status_response import UpdateDocumentStatusResponse
+
+
+class Document:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def create_by_file(
+        self, request: CreateDocumentByFileRequest, request_option: RequestOption
+    ) -> CreateDocumentByFileResponse:
+        return Transport.execute(self.config, request, unmarshal_as=CreateDocumentByFileResponse, option=request_option)
+
+    async def acreate_by_file(
+        self, request: CreateDocumentByFileRequest, request_option: RequestOption
+    ) -> CreateDocumentByFileResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=CreateDocumentByFileResponse, option=request_option
+        )
+
+    def create_by_text(
+        self, request: CreateDocumentByTextRequest, request_option: RequestOption
+    ) -> CreateDocumentByTextResponse:
+        return Transport.execute(self.config, request, unmarshal_as=CreateDocumentByTextResponse, option=request_option)
+
+    async def acreate_by_text(
+        self, request: CreateDocumentByTextRequest, request_option: RequestOption
+    ) -> CreateDocumentByTextResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=CreateDocumentByTextResponse, option=request_option
+        )
+
+    def list(self, request: ListDocumentsRequest, request_option: RequestOption) -> ListDocumentsResponse:
+        return Transport.execute(self.config, request, unmarshal_as=ListDocumentsResponse, option=request_option)
+
+    async def alist(self, request: ListDocumentsRequest, request_option: RequestOption) -> ListDocumentsResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=ListDocumentsResponse, option=request_option
+        )
+
+    def get(self, request: GetDocumentRequest, request_option: RequestOption) -> GetDocumentResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetDocumentResponse, option=request_option)
+
+    async def aget(self, request: GetDocumentRequest, request_option: RequestOption) -> GetDocumentResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=GetDocumentResponse, option=request_option)
+
+    def update_by_file(
+        self, request: UpdateDocumentByFileRequest, request_option: RequestOption
+    ) -> UpdateDocumentByFileResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateDocumentByFileResponse, option=request_option)
+
+    async def aupdate_by_file(
+        self, request: UpdateDocumentByFileRequest, request_option: RequestOption
+    ) -> UpdateDocumentByFileResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=UpdateDocumentByFileResponse, option=request_option
+        )
+
+    def update_by_text(
+        self, request: UpdateDocumentByTextRequest, request_option: RequestOption
+    ) -> UpdateDocumentByTextResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateDocumentByTextResponse, option=request_option)
+
+    async def aupdate_by_text(
+        self, request: UpdateDocumentByTextRequest, request_option: RequestOption
+    ) -> UpdateDocumentByTextResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=UpdateDocumentByTextResponse, option=request_option
+        )
+
+    def delete(self, request: DeleteDocumentRequest, request_option: RequestOption) -> DeleteDocumentResponse:
+        return Transport.execute(self.config, request, unmarshal_as=DeleteDocumentResponse, option=request_option)
+
+    async def adelete(self, request: DeleteDocumentRequest, request_option: RequestOption) -> DeleteDocumentResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=DeleteDocumentResponse, option=request_option
+        )
+
+    def file_info(self, request: GetUploadFileInfoRequest, request_option: RequestOption) -> GetUploadFileInfoResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetUploadFileInfoResponse, option=request_option)
+
+    async def afile_info(
+        self, request: GetUploadFileInfoRequest, request_option: RequestOption
+    ) -> GetUploadFileInfoResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetUploadFileInfoResponse, option=request_option
+        )
+
+    def update_status(
+        self, request: UpdateDocumentStatusRequest, request_option: RequestOption
+    ) -> UpdateDocumentStatusResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateDocumentStatusResponse, option=request_option)
+
+    async def aupdate_status(
+        self, request: UpdateDocumentStatusRequest, request_option: RequestOption
+    ) -> UpdateDocumentStatusResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=UpdateDocumentStatusResponse, option=request_option
+        )
+
+    def get_batch_status(
+        self, request: GetBatchIndexingStatusRequest, request_option: RequestOption
+    ) -> GetBatchIndexingStatusResponse:
+        return Transport.execute(
+            self.config, request, unmarshal_as=GetBatchIndexingStatusResponse, option=request_option
+        )
+
+    async def aget_batch_status(
+        self, request: GetBatchIndexingStatusRequest, request_option: RequestOption
+    ) -> GetBatchIndexingStatusResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetBatchIndexingStatusResponse, option=request_option
+        )

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

@@ -0,0 +1,25 @@
+from dify_oapi.core.http.transport import ATransport, Transport
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.request_option import RequestOption
+
+from ..model.get_text_embedding_models_request import GetTextEmbeddingModelsRequest
+from ..model.get_text_embedding_models_response import GetTextEmbeddingModelsResponse
+
+
+class Model:
+    def __init__(self, config: Config):
+        self.config = config
+
+    def embedding_models(
+        self, request: GetTextEmbeddingModelsRequest, request_option: RequestOption
+    ) -> GetTextEmbeddingModelsResponse:
+        return Transport.execute(
+            self.config, request, unmarshal_as=GetTextEmbeddingModelsResponse, option=request_option
+        )
+
+    async def aembedding_models(
+        self, request: GetTextEmbeddingModelsRequest, request_option: RequestOption
+    ) -> GetTextEmbeddingModelsResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetTextEmbeddingModelsResponse, option=request_option
+        )

dify_oapi/api/knowledge/v1/resource/segment.py

@@ -0,0 +1,55 @@
+from dify_oapi.core.http.transport import ATransport, Transport
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.request_option import RequestOption
+
+from ..model.create_segment_request import CreateSegmentRequest
+from ..model.create_segment_response import CreateSegmentResponse
+from ..model.delete_segment_request import DeleteSegmentRequest
+from ..model.delete_segment_response import DeleteSegmentResponse
+from ..model.get_segment_request import GetSegmentRequest
+from ..model.get_segment_response import GetSegmentResponse
+from ..model.list_segments_request import ListSegmentsRequest
+from ..model.list_segments_response import ListSegmentsResponse
+from ..model.update_segment_request import UpdateSegmentRequest
+from ..model.update_segment_response import UpdateSegmentResponse
+
+
+class Segment:
+    def __init__(self, config: Config):
+        self.config = config
+
+    def list(self, request: ListSegmentsRequest, request_option: RequestOption) -> ListSegmentsResponse:
+        return Transport.execute(self.config, request, unmarshal_as=ListSegmentsResponse, option=request_option)
+
+    async def alist(self, request: ListSegmentsRequest, request_option: RequestOption) -> ListSegmentsResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=ListSegmentsResponse, option=request_option)
+
+    def create(self, request: CreateSegmentRequest, request_option: RequestOption) -> CreateSegmentResponse:
+        return Transport.execute(self.config, request, unmarshal_as=CreateSegmentResponse, option=request_option)
+
+    async def acreate(self, request: CreateSegmentRequest, request_option: RequestOption) -> CreateSegmentResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=CreateSegmentResponse, option=request_option
+        )
+
+    def get(self, request: GetSegmentRequest, request_option: RequestOption) -> GetSegmentResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetSegmentResponse, option=request_option)
+
+    async def aget(self, request: GetSegmentRequest, request_option: RequestOption) -> GetSegmentResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=GetSegmentResponse, option=request_option)
+
+    def update(self, request: UpdateSegmentRequest, request_option: RequestOption) -> UpdateSegmentResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateSegmentResponse, option=request_option)
+
+    async def aupdate(self, request: UpdateSegmentRequest, request_option: RequestOption) -> UpdateSegmentResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=UpdateSegmentResponse, option=request_option
+        )
+
+    def delete(self, request: DeleteSegmentRequest, request_option: RequestOption) -> DeleteSegmentResponse:
+        return Transport.execute(self.config, request, unmarshal_as=DeleteSegmentResponse, option=request_option)
+
+    async def adelete(self, request: DeleteSegmentRequest, request_option: RequestOption) -> DeleteSegmentResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=DeleteSegmentResponse, option=request_option
+        )

dify_oapi/api/knowledge/v1/resource/tag.py

@@ -0,0 +1,81 @@
+from dify_oapi.core.http.transport import ATransport, Transport
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.request_option import RequestOption
+
+from ..model.bind_tags_to_dataset_request import BindTagsToDatasetRequest
+from ..model.bind_tags_to_dataset_response import BindTagsToDatasetResponse
+from ..model.create_tag_request import CreateTagRequest
+from ..model.create_tag_response import CreateTagResponse
+from ..model.delete_tag_request import DeleteTagRequest
+from ..model.delete_tag_response import DeleteTagResponse
+from ..model.get_dataset_tags_request import GetDatasetTagsRequest
+from ..model.get_dataset_tags_response import GetDatasetTagsResponse
+from ..model.list_tags_request import ListTagsRequest
+from ..model.list_tags_response import ListTagsResponse
+from ..model.unbind_tags_from_dataset_request import UnbindTagsFromDatasetRequest
+from ..model.unbind_tags_from_dataset_response import UnbindTagsFromDatasetResponse
+from ..model.update_tag_request import UpdateTagRequest
+from ..model.update_tag_response import UpdateTagResponse
+
+
+class Tag:
+    def __init__(self, config: Config):
+        self.config = config
+
+    def list(self, request: ListTagsRequest, request_option: RequestOption) -> ListTagsResponse:
+        return Transport.execute(self.config, request, unmarshal_as=ListTagsResponse, option=request_option)
+
+    async def alist(self, request: ListTagsRequest, request_option: RequestOption) -> ListTagsResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=ListTagsResponse, option=request_option)
+
+    def create(self, request: CreateTagRequest, request_option: RequestOption) -> CreateTagResponse:
+        return Transport.execute(self.config, request, unmarshal_as=CreateTagResponse, option=request_option)
+
+    async def acreate(self, request: CreateTagRequest, request_option: RequestOption) -> CreateTagResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=CreateTagResponse, option=request_option)
+
+    def update(self, request: UpdateTagRequest, request_option: RequestOption) -> UpdateTagResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateTagResponse, option=request_option)
+
+    async def aupdate(self, request: UpdateTagRequest, request_option: RequestOption) -> UpdateTagResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=UpdateTagResponse, option=request_option)
+
+    def delete(self, request: DeleteTagRequest, request_option: RequestOption) -> DeleteTagResponse:
+        return Transport.execute(self.config, request, unmarshal_as=DeleteTagResponse, option=request_option)
+
+    async def adelete(self, request: DeleteTagRequest, request_option: RequestOption) -> DeleteTagResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=DeleteTagResponse, option=request_option)
+
+    def bind(self, request: BindTagsToDatasetRequest, request_option: RequestOption) -> BindTagsToDatasetResponse:
+        return Transport.execute(self.config, request, unmarshal_as=BindTagsToDatasetResponse, option=request_option)
+
+    async def abind(
+        self, request: BindTagsToDatasetRequest, request_option: RequestOption
+    ) -> BindTagsToDatasetResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=BindTagsToDatasetResponse, option=request_option
+        )
+
+    def unbind(
+        self, request: UnbindTagsFromDatasetRequest, request_option: RequestOption
+    ) -> UnbindTagsFromDatasetResponse:
+        return Transport.execute(
+            self.config, request, unmarshal_as=UnbindTagsFromDatasetResponse, option=request_option
+        )
+
+    async def aunbind(
+        self, request: UnbindTagsFromDatasetRequest, request_option: RequestOption
+    ) -> UnbindTagsFromDatasetResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=UnbindTagsFromDatasetResponse, option=request_option
+        )
+
+    def get_dataset_tags(self, request: GetDatasetTagsRequest, request_option: RequestOption) -> GetDatasetTagsResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetDatasetTagsResponse, option=request_option)
+
+    async def aget_dataset_tags(
+        self, request: GetDatasetTagsRequest, request_option: RequestOption
+    ) -> GetDatasetTagsResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetDatasetTagsResponse, option=request_option
+        )

dify_oapi/api/knowledge/v1/version.py

@@ -0,0 +1,18 @@
+from dify_oapi.core.model.config import Config
+
+from .resource.chunk import Chunk
+from .resource.dataset import Dataset
+from .resource.document import Document
+from .resource.model import Model
+from .resource.segment import Segment
+from .resource.tag import Tag
+
+
+class V1:
+    def __init__(self, config: Config):
+        self.dataset = Dataset(config)
+        self.document = Document(config)
+        self.segment = Segment(config)
+        self.chunk = Chunk(config)
+        self.tag = Tag(config)
+        self.model = Model(config)