dify-oapi2 0.1.0__py3-none-any.whl

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

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

dify_oapi/api/knowledge_base/v1/model/tag/create_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 .create_request_body import CreateRequestBody
+
+
+class CreateRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.request_body: CreateRequestBody | None = None
+
+    @staticmethod
+    def builder() -> CreateRequestBuilder:
+        return CreateRequestBuilder()
+
+
+class CreateRequestBuilder:
+    def __init__(self):
+        create_request = CreateRequest()
+        create_request.http_method = HttpMethod.POST
+        create_request.uri = "/v1/datasets/tags"
+        self._request = create_request
+
+    def build(self) -> CreateRequest:
+        return self._request
+
+    def request_body(self, request_body: CreateRequestBody) -> CreateRequestBuilder:
+        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/create_request_body.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class CreateRequestBody(BaseModel):
+    name: str = ""
+
+    @staticmethod
+    def builder() -> CreateRequestBodyBuilder:
+        return CreateRequestBodyBuilder()
+
+
+class CreateRequestBodyBuilder:
+    def __init__(self):
+        create_request_body = CreateRequestBody()
+        self._request_body = create_request_body
+
+    def build(self) -> CreateRequestBody:
+        return self._request_body
+
+    def name(self, name: str) -> CreateRequestBodyBuilder:
+        self._request_body.name = name
+        return self

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

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from dify_oapi.api.knowledge_base.v1.model.tag.tag_info import TagInfo
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class CreateResponse(BaseResponse):
+    id: str | None = None
+    name: str | None = None
+    type: str | None = None
+    binding_count: int | None = None
+
+    def to_tag_info(self) -> TagInfo:
+        return TagInfo(
+            id=self.id or "", name=self.name or "", type=self.type or "", binding_count=self.binding_count or 0
+        )

dify_oapi/api/knowledge_base/v1/model/tag/delete_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 .delete_request_body import DeleteRequestBody
+
+
+class DeleteRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.request_body: DeleteRequestBody | 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/tags"
+        self._request = delete_request
+
+    def build(self) -> DeleteRequest:
+        return self._request
+
+    def request_body(self, request_body: DeleteRequestBody) -> DeleteRequestBuilder:
+        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/delete_request_body.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class DeleteRequestBody(BaseModel):
+    tag_id: str = ""
+
+    @staticmethod
+    def builder() -> DeleteRequestBodyBuilder:
+        return DeleteRequestBodyBuilder()
+
+
+class DeleteRequestBodyBuilder:
+    def __init__(self):
+        delete_request_body = DeleteRequestBody()
+        self._request_body = delete_request_body
+
+    def build(self) -> DeleteRequestBody:
+        return self._request_body
+
+    def tag_id(self, tag_id: str) -> DeleteRequestBodyBuilder:
+        self._request_body.tag_id = tag_id
+        return self

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

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

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

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class ListRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+
+    @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/tags"
+        self._request = list_request
+
+    def build(self) -> ListRequest:
+        return self._request

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

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from dify_oapi.api.knowledge_base.v1.model.tag.tag_info import TagInfo
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class ListResponse(BaseResponse):
+    # For tag list API, the response is directly an array
+    # We'll handle this in the transport layer by wrapping the array
+    data: list[TagInfo] = []
+
+    def __iter__(self):
+        return iter(self.data)
+
+    def __getitem__(self, item):
+        return self.data[item]
+
+    def __len__(self):
+        return len(self.data)

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

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+
+class QueryBoundRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.dataset_id: str | None = None
+
+    @staticmethod
+    def builder() -> QueryBoundRequestBuilder:
+        return QueryBoundRequestBuilder()
+
+
+class QueryBoundRequestBuilder:
+    def __init__(self):
+        query_bound_request = QueryBoundRequest()
+        query_bound_request.http_method = HttpMethod.GET
+        query_bound_request.uri = "/v1/datasets/:dataset_id/tags"
+        self._request = query_bound_request
+
+    def build(self) -> QueryBoundRequest:
+        return self._request
+
+    def dataset_id(self, dataset_id: str) -> QueryBoundRequestBuilder:
+        self._request.dataset_id = dataset_id
+        self._request.paths["dataset_id"] = dataset_id
+        return self

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

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dify_oapi.api.knowledge_base.v1.model.tag.tag_info import TagInfo
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class QueryBoundResponse(BaseResponse):
+    data: list[TagInfo] = []
+    total: int = 0

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

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class TagInfo(BaseModel):
+    id: str
+    name: str
+    type: str | None = None
+    binding_count: int | None = None
+
+    @staticmethod
+    def builder() -> TagInfoBuilder:
+        return TagInfoBuilder()
+
+
+class TagInfoBuilder:
+    def __init__(self):
+        self._tag_info = TagInfo(id="", name="")
+
+    def build(self) -> TagInfo:
+        return self._tag_info
+
+    def id(self, id: str) -> TagInfoBuilder:
+        self._tag_info.id = id
+        return self
+
+    def name(self, name: str) -> TagInfoBuilder:
+        self._tag_info.name = name
+        return self
+
+    def type(self, type: str) -> TagInfoBuilder:
+        self._tag_info.type = type
+        return self
+
+    def binding_count(self, binding_count: int) -> TagInfoBuilder:
+        self._tag_info.binding_count = binding_count
+        return self

dify_oapi/api/knowledge_base/v1/model/tag/unbind_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 .unbind_request_body import UnbindRequestBody
+
+
+class UnbindRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.request_body: UnbindRequestBody | None = None
+
+    @staticmethod
+    def builder() -> UnbindRequestBuilder:
+        return UnbindRequestBuilder()
+
+
+class UnbindRequestBuilder:
+    def __init__(self):
+        unbind_request = UnbindRequest()
+        unbind_request.http_method = HttpMethod.POST
+        unbind_request.uri = "/v1/datasets/tags/unbinding"
+        self._request = unbind_request
+
+    def build(self) -> UnbindRequest:
+        return self._request
+
+    def request_body(self, request_body: UnbindRequestBody) -> UnbindRequestBuilder:
+        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/unbind_request_body.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class UnbindRequestBody(BaseModel):
+    tag_id: str = ""
+    target_id: str = ""
+
+    @staticmethod
+    def builder() -> UnbindRequestBodyBuilder:
+        return UnbindRequestBodyBuilder()
+
+
+class UnbindRequestBodyBuilder:
+    def __init__(self):
+        unbind_request_body = UnbindRequestBody()
+        self._request_body = unbind_request_body
+
+    def build(self) -> UnbindRequestBody:
+        return self._request_body
+
+    def tag_id(self, tag_id: str) -> UnbindRequestBodyBuilder:
+        self._request_body.tag_id = tag_id
+        return self
+
+    def target_id(self, target_id: str) -> UnbindRequestBodyBuilder:
+        self._request_body.target_id = target_id
+        return self

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

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

dify_oapi/api/knowledge_base/v1/model/tag/update_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 .update_request_body import UpdateRequestBody
+
+
+class UpdateRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        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.PATCH
+        update_request.uri = "/v1/datasets/tags"
+        self._request = update_request
+
+    def build(self) -> UpdateRequest:
+        return self._request
+
+    def request_body(self, request_body: UpdateRequestBody) -> UpdateRequestBuilder:
+        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/update_request_body.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class UpdateRequestBody(BaseModel):
+    name: str = ""
+    tag_id: str = ""
+
+    @staticmethod
+    def builder() -> UpdateRequestBodyBuilder:
+        return UpdateRequestBodyBuilder()
+
+
+class UpdateRequestBodyBuilder:
+    def __init__(self):
+        update_request_body = UpdateRequestBody()
+        self._request_body = update_request_body
+
+    def build(self) -> UpdateRequestBody:
+        return self._request_body
+
+    def name(self, name: str) -> UpdateRequestBodyBuilder:
+        self._request_body.name = name
+        return self
+
+    def tag_id(self, tag_id: str) -> UpdateRequestBodyBuilder:
+        self._request_body.tag_id = tag_id
+        return self

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

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from dify_oapi.api.knowledge_base.v1.model.tag.tag_info import TagInfo
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class UpdateResponse(BaseResponse):
+    id: str | None = None
+    name: str | None = None
+    type: str | None = None
+    binding_count: int | str | None = None
+
+    def to_tag_info(self) -> TagInfo:
+        return TagInfo(
+            id=self.id or "",
+            name=self.name or "",
+            type=self.type or "",
+            binding_count=self.binding_count or 0,
+        )

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

@@ -0,0 +1,7 @@
+from .dataset import Dataset
+from .document import Document
+from .metadata import Metadata
+from .segment import Segment
+from .tag import Tag
+
+__all__ = ["Dataset", "Document", "Metadata", "Segment", "Tag"]

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

@@ -0,0 +1,58 @@
+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
+
+# New dataset models
+from ..model.dataset.create_request import CreateRequest
+from ..model.dataset.create_response import CreateResponse
+from ..model.dataset.delete_request import DeleteRequest
+from ..model.dataset.delete_response import DeleteResponse
+from ..model.dataset.get_request import GetRequest
+from ..model.dataset.get_response import GetResponse
+from ..model.dataset.list_request import ListRequest
+from ..model.dataset.list_response import ListResponse
+from ..model.dataset.retrieve_request import RetrieveRequest
+from ..model.dataset.retrieve_response import RetrieveResponse
+from ..model.dataset.update_request import UpdateRequest
+from ..model.dataset.update_response import UpdateResponse
+
+
+class Dataset:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def create(self, request: CreateRequest, option: RequestOption | None = None) -> CreateResponse:
+        return Transport.execute(self.config, request, unmarshal_as=CreateResponse, option=option)
+
+    async def acreate(self, request: CreateRequest, option: RequestOption | None = None) -> CreateResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=CreateResponse, option=option)
+
+    def list(self, request: ListRequest, option: RequestOption | None = None) -> ListResponse:
+        return Transport.execute(self.config, request, unmarshal_as=ListResponse, option=option)
+
+    async def alist(self, request: ListRequest, option: RequestOption | None = None) -> ListResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=ListResponse, option=option)
+
+    def get(self, request: GetRequest, option: RequestOption | None = None) -> GetResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetResponse, option=option)
+
+    async def aget(self, request: GetRequest, option: RequestOption | None = None) -> GetResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=GetResponse, option=option)
+
+    def update(self, request: UpdateRequest, option: RequestOption | None = None) -> UpdateResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateResponse, option=option)
+
+    async def aupdate(self, request: UpdateRequest, option: RequestOption | None = None) -> UpdateResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=UpdateResponse, option=option)
+
+    def delete(self, request: DeleteRequest, option: RequestOption | None = None) -> DeleteResponse:
+        return Transport.execute(self.config, request, unmarshal_as=DeleteResponse, option=option)
+
+    async def adelete(self, request: DeleteRequest, option: RequestOption | None = None) -> DeleteResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=DeleteResponse, option=option)
+
+    def retrieve(self, request: RetrieveRequest, option: RequestOption | None = None) -> RetrieveResponse:
+        return Transport.execute(self.config, request, unmarshal_as=RetrieveResponse, option=option)
+
+    async def aretrieve(self, request: RetrieveRequest, option: RequestOption | None = None) -> RetrieveResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=RetrieveResponse, option=option)

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

@@ -0,0 +1,107 @@
+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.document.create_by_file_request import CreateByFileRequest
+from ..model.document.create_by_file_response import CreateByFileResponse
+from ..model.document.create_by_text_request import CreateByTextRequest
+from ..model.document.create_by_text_response import CreateByTextResponse
+from ..model.document.delete_request import DeleteRequest
+from ..model.document.delete_response import DeleteResponse
+from ..model.document.get_request import GetRequest
+from ..model.document.get_response import GetResponse
+from ..model.document.get_upload_file_request import GetUploadFileRequest
+from ..model.document.get_upload_file_response import GetUploadFileResponse
+from ..model.document.indexing_status_request import IndexingStatusRequest
+from ..model.document.indexing_status_response import IndexingStatusResponse
+from ..model.document.list_request import ListRequest
+from ..model.document.list_response import ListResponse
+from ..model.document.update_by_file_request import UpdateByFileRequest
+from ..model.document.update_by_file_response import UpdateByFileResponse
+from ..model.document.update_by_text_request import UpdateByTextRequest
+from ..model.document.update_by_text_response import UpdateByTextResponse
+from ..model.document.update_status_request import UpdateStatusRequest
+from ..model.document.update_status_response import UpdateStatusResponse
+
+
+class Document:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def create_by_text(self, request: CreateByTextRequest, option: RequestOption | None = None) -> CreateByTextResponse:
+        return Transport.execute(self.config, request, unmarshal_as=CreateByTextResponse, option=option)
+
+    async def acreate_by_text(
+        self, request: CreateByTextRequest, option: RequestOption | None = None
+    ) -> CreateByTextResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=CreateByTextResponse, option=option)
+
+    def update_by_text(self, request: UpdateByTextRequest, option: RequestOption | None = None) -> UpdateByTextResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateByTextResponse, option=option)
+
+    async def aupdate_by_text(
+        self, request: UpdateByTextRequest, option: RequestOption | None = None
+    ) -> UpdateByTextResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=UpdateByTextResponse, option=option)
+
+    def create_by_file(self, request: CreateByFileRequest, option: RequestOption | None = None) -> CreateByFileResponse:
+        return Transport.execute(self.config, request, unmarshal_as=CreateByFileResponse, option=option)
+
+    async def acreate_by_file(
+        self, request: CreateByFileRequest, option: RequestOption | None = None
+    ) -> CreateByFileResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=CreateByFileResponse, option=option)
+
+    def update_by_file(self, request: UpdateByFileRequest, option: RequestOption | None = None) -> UpdateByFileResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateByFileResponse, option=option)
+
+    async def aupdate_by_file(
+        self, request: UpdateByFileRequest, option: RequestOption | None = None
+    ) -> UpdateByFileResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=UpdateByFileResponse, option=option)
+
+    def list(self, request: ListRequest, option: RequestOption | None = None) -> ListResponse:
+        return Transport.execute(self.config, request, unmarshal_as=ListResponse, option=option)
+
+    async def alist(self, request: ListRequest, option: RequestOption | None = None) -> ListResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=ListResponse, option=option)
+
+    def delete(self, request: DeleteRequest, option: RequestOption | None = None) -> DeleteResponse:
+        return Transport.execute(self.config, request, unmarshal_as=DeleteResponse, option=option)
+
+    async def adelete(self, request: DeleteRequest, option: RequestOption | None = None) -> DeleteResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=DeleteResponse, option=option)
+
+    def indexing_status(
+        self, request: IndexingStatusRequest, option: RequestOption | None = None
+    ) -> IndexingStatusResponse:
+        return Transport.execute(self.config, request, unmarshal_as=IndexingStatusResponse, option=option)
+
+    async def aindexing_status(
+        self, request: IndexingStatusRequest, option: RequestOption | None = None
+    ) -> IndexingStatusResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=IndexingStatusResponse, option=option)
+
+    def get(self, request: GetRequest, option: RequestOption | None = None) -> GetResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetResponse, option=option)
+
+    async def aget(self, request: GetRequest, option: RequestOption | None = None) -> GetResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=GetResponse, option=option)
+
+    def update_status(self, request: UpdateStatusRequest, option: RequestOption | None = None) -> UpdateStatusResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateStatusResponse, option=option)
+
+    async def aupdate_status(
+        self, request: UpdateStatusRequest, option: RequestOption | None = None
+    ) -> UpdateStatusResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=UpdateStatusResponse, option=option)
+
+    def get_upload_file(
+        self, request: GetUploadFileRequest, option: RequestOption | None = None
+    ) -> GetUploadFileResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetUploadFileResponse, option=option)
+
+    async def aget_upload_file(
+        self, request: GetUploadFileRequest, option: RequestOption | None = None
+    ) -> GetUploadFileResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=GetUploadFileResponse, option=option)