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

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

@@ -0,0 +1,68 @@
+"""Update document by file request body model."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .knowledge_types import IndexingTechnique
+from .process_rule import ProcessRule
+from .retrieval_model import RetrievalModel
+
+
+class UpdateDocumentByFileRequestBody(BaseModel):
+    """Request body model for update document by file API."""
+
+    name: str | None = None
+    indexing_technique: IndexingTechnique | None = None
+    doc_form: str | 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() -> UpdateDocumentByFileRequestBodyBuilder:
+        return UpdateDocumentByFileRequestBodyBuilder()
+
+
+class UpdateDocumentByFileRequestBodyBuilder:
+    """Builder for UpdateDocumentByFileRequestBody."""
+
+    def __init__(self) -> None:
+        self._update_document_by_file_request_body = UpdateDocumentByFileRequestBody()
+
+    def build(self) -> UpdateDocumentByFileRequestBody:
+        return self._update_document_by_file_request_body
+
+    def name(self, name: str) -> UpdateDocumentByFileRequestBodyBuilder:
+        self._update_document_by_file_request_body.name = name
+        return self
+
+    def indexing_technique(self, indexing_technique: IndexingTechnique) -> UpdateDocumentByFileRequestBodyBuilder:
+        self._update_document_by_file_request_body.indexing_technique = indexing_technique
+        return self
+
+    def process_rule(self, process_rule: ProcessRule) -> UpdateDocumentByFileRequestBodyBuilder:
+        self._update_document_by_file_request_body.process_rule = process_rule
+        return self
+
+    def doc_form(self, doc_form: str) -> UpdateDocumentByFileRequestBodyBuilder:
+        self._update_document_by_file_request_body.doc_form = doc_form
+        return self
+
+    def doc_language(self, doc_language: str) -> UpdateDocumentByFileRequestBodyBuilder:
+        self._update_document_by_file_request_body.doc_language = doc_language
+        return self
+
+    def retrieval_model(self, retrieval_model: RetrievalModel) -> UpdateDocumentByFileRequestBodyBuilder:
+        self._update_document_by_file_request_body.retrieval_model = retrieval_model
+        return self
+
+    def embedding_model(self, embedding_model: str) -> UpdateDocumentByFileRequestBodyBuilder:
+        self._update_document_by_file_request_body.embedding_model = embedding_model
+        return self
+
+    def embedding_model_provider(self, embedding_model_provider: str) -> UpdateDocumentByFileRequestBodyBuilder:
+        self._update_document_by_file_request_body.embedding_model_provider = embedding_model_provider
+        return self

dify_oapi/api/{knowledge_base/v1/model/document/update_by_file_response.py → knowledge/v1/model/update_document_by_file_response.py}

@@ -1,12 +1,12 @@
-from __future__ import annotations
+"""Update document by file response model."""
 
 from dify_oapi.core.model.base_response import BaseResponse
 
 from .document_info import DocumentInfo
 
 
-class UpdateByFileResponse(BaseResponse):
-    """Response model for update document by file API"""
+class UpdateDocumentByFileResponse(BaseResponse):
+    """Response model for update document by file API."""
 
     document: DocumentInfo | None = None
     batch: str | None = None

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

@@ -0,0 +1,50 @@
+"""Update 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 .update_document_by_text_request_body import UpdateDocumentByTextRequestBody
+
+
+class UpdateDocumentByTextRequest(BaseRequest):
+    """Request model for update document by text API."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.document_id: str | None = None
+        self.request_body: UpdateDocumentByTextRequestBody | None = None
+
+    @staticmethod
+    def builder() -> UpdateDocumentByTextRequestBuilder:
+        return UpdateDocumentByTextRequestBuilder()
+
+
+class UpdateDocumentByTextRequestBuilder:
+    """Builder for UpdateDocumentByTextRequest."""
+
+    def __init__(self) -> None:
+        update_document_by_text_request = UpdateDocumentByTextRequest()
+        update_document_by_text_request.http_method = HttpMethod.POST
+        update_document_by_text_request.uri = "/v1/datasets/:dataset_id/documents/:document_id/update-by-text"
+        self._update_document_by_text_request = update_document_by_text_request
+
+    def build(self) -> UpdateDocumentByTextRequest:
+        return self._update_document_by_text_request
+
+    def dataset_id(self, dataset_id: str) -> UpdateDocumentByTextRequestBuilder:
+        self._update_document_by_text_request.dataset_id = dataset_id
+        self._update_document_by_text_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def document_id(self, document_id: str) -> UpdateDocumentByTextRequestBuilder:
+        self._update_document_by_text_request.document_id = document_id
+        self._update_document_by_text_request.paths["document_id"] = document_id
+        return self
+
+    def request_body(self, request_body: UpdateDocumentByTextRequestBody) -> UpdateDocumentByTextRequestBuilder:
+        self._update_document_by_text_request.request_body = request_body
+        self._update_document_by_text_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

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

@@ -0,0 +1,73 @@
+"""Update document by text request body model."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .knowledge_types import IndexingTechnique
+from .process_rule import ProcessRule
+from .retrieval_model import RetrievalModel
+
+
+class UpdateDocumentByTextRequestBody(BaseModel):
+    """Request body model for update document by text API."""
+
+    name: str | None = None
+    text: str | None = None
+    indexing_technique: IndexingTechnique | None = None
+    doc_form: str | 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() -> UpdateDocumentByTextRequestBodyBuilder:
+        return UpdateDocumentByTextRequestBodyBuilder()
+
+
+class UpdateDocumentByTextRequestBodyBuilder:
+    """Builder for UpdateDocumentByTextRequestBody."""
+
+    def __init__(self) -> None:
+        self._update_document_by_text_request_body = UpdateDocumentByTextRequestBody()
+
+    def build(self) -> UpdateDocumentByTextRequestBody:
+        return self._update_document_by_text_request_body
+
+    def name(self, name: str) -> UpdateDocumentByTextRequestBodyBuilder:
+        self._update_document_by_text_request_body.name = name
+        return self
+
+    def text(self, text: str) -> UpdateDocumentByTextRequestBodyBuilder:
+        self._update_document_by_text_request_body.text = text
+        return self
+
+    def indexing_technique(self, indexing_technique: IndexingTechnique) -> UpdateDocumentByTextRequestBodyBuilder:
+        self._update_document_by_text_request_body.indexing_technique = indexing_technique
+        return self
+
+    def process_rule(self, process_rule: ProcessRule) -> UpdateDocumentByTextRequestBodyBuilder:
+        self._update_document_by_text_request_body.process_rule = process_rule
+        return self
+
+    def doc_form(self, doc_form: str) -> UpdateDocumentByTextRequestBodyBuilder:
+        self._update_document_by_text_request_body.doc_form = doc_form
+        return self
+
+    def doc_language(self, doc_language: str) -> UpdateDocumentByTextRequestBodyBuilder:
+        self._update_document_by_text_request_body.doc_language = doc_language
+        return self
+
+    def retrieval_model(self, retrieval_model: RetrievalModel) -> UpdateDocumentByTextRequestBodyBuilder:
+        self._update_document_by_text_request_body.retrieval_model = retrieval_model
+        return self
+
+    def embedding_model(self, embedding_model: str) -> UpdateDocumentByTextRequestBodyBuilder:
+        self._update_document_by_text_request_body.embedding_model = embedding_model
+        return self
+
+    def embedding_model_provider(self, embedding_model_provider: str) -> UpdateDocumentByTextRequestBodyBuilder:
+        self._update_document_by_text_request_body.embedding_model_provider = embedding_model_provider
+        return self

dify_oapi/api/{knowledge_base/v1/model/document/update_by_text_response.py → knowledge/v1/model/update_document_by_text_response.py}

@@ -1,14 +1,12 @@
 """Update document by text response model."""
 
-from __future__ import annotations
-
 from dify_oapi.core.model.base_response import BaseResponse
 
 from .document_info import DocumentInfo
 
 
-class UpdateByTextResponse(BaseResponse):
-    """Response model for updating document by text."""
+class UpdateDocumentByTextResponse(BaseResponse):
+    """Response model for update document by text API."""
 
     document: DocumentInfo | None = None
     batch: str | None = None

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

@@ -0,0 +1,51 @@
+"""Update document status request model."""
+
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .knowledge_types import DocumentStatusAction
+from .update_document_status_request_body import UpdateDocumentStatusRequestBody
+
+
+class UpdateDocumentStatusRequest(BaseRequest):
+    """Request model for update document status API."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.action: DocumentStatusAction | None = None
+        self.request_body: UpdateDocumentStatusRequestBody | None = None
+
+    @staticmethod
+    def builder() -> UpdateDocumentStatusRequestBuilder:
+        return UpdateDocumentStatusRequestBuilder()
+
+
+class UpdateDocumentStatusRequestBuilder:
+    """Builder for UpdateDocumentStatusRequest."""
+
+    def __init__(self) -> None:
+        update_document_status_request = UpdateDocumentStatusRequest()
+        update_document_status_request.http_method = HttpMethod.PATCH
+        update_document_status_request.uri = "/v1/datasets/:dataset_id/documents/status/:action"
+        self._update_document_status_request = update_document_status_request
+
+    def build(self) -> UpdateDocumentStatusRequest:
+        return self._update_document_status_request
+
+    def dataset_id(self, dataset_id: str) -> UpdateDocumentStatusRequestBuilder:
+        self._update_document_status_request.dataset_id = dataset_id
+        self._update_document_status_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def action(self, action: DocumentStatusAction) -> UpdateDocumentStatusRequestBuilder:
+        self._update_document_status_request.action = action
+        self._update_document_status_request.paths["action"] = action
+        return self
+
+    def request_body(self, request_body: UpdateDocumentStatusRequestBody) -> UpdateDocumentStatusRequestBuilder:
+        self._update_document_status_request.request_body = request_body
+        self._update_document_status_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

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/model/weights.py

@@ -0,0 +1,27 @@
+"""Weights model for retrieval configuration."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class KeywordSetting(BaseModel):
+    """Keyword search weight settings."""
+
+    keyword_weight: Optional[float] = None
+
+
+class VectorSetting(BaseModel):
+    """Vector search weight settings."""
+
+    vector_weight: Optional[float] = None
+    embedding_model_name: Optional[str] = None
+    embedding_provider_name: Optional[str] = None
+
+
+class Weights(BaseModel):
+    """Weights configuration for hybrid search."""
+
+    weight_type: Optional[str] = None
+    keyword_setting: Optional[KeywordSetting] = None
+    vector_setting: Optional[VectorSetting] = None

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
+        )