From 26754f58653c1ee20069c93c9758a16067625627 Mon Sep 17 00:00:00 2001
From: linhaoyang <893820382@qq.com>
Date: Sun, 8 Oct 2023 15:29:32 +0800
Subject: [PATCH 1/4] =?UTF-8?q?=E4=BF=AE=E5=A4=8DREADME=E4=B8=AD=E9=94=99?=
 =?UTF-8?q?=E8=AF=AF=E6=8F=8F=E8=BF=B0=20pypi=E8=B0=83=E6=95=B4=E4=B8=BA0.?=
 =?UTF-8?q?2.0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md | 2 +-
 setup.py  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 970b0fc..a32eb24 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,7 @@ pip install -U "prefect"
 
 pip install prefect-hwc
 
-prefect block register --module prefect-hwc
+prefect block register --module prefect_huaweicloud
 ```
 
 ## Contributing
diff --git a/setup.py b/setup.py
index 11f6623..616e6a6 100644
--- a/setup.py
+++ b/setup.py
@@ -14,7 +14,7 @@ setup(
     author_email="",
     keywords="prefect",
     url="https://gitee.com/HuaweiCloudDeveloper/huaweicloud-prefect-block-python",
-    version="0.1.0",
+    version="0.2.0",
     long_description=open("README.md").read(),
     long_description_content_type="text/markdown",
     python_requires=">=3.9",
-- 
Gitee


From 1c448873e6a3a71081d77410276e565109ca51a8 Mon Sep 17 00:00:00 2001
From: lky0312 <523175094@qq.com>
Date: Tue, 26 Dec 2023 14:29:25 +0800
Subject: [PATCH 2/4] first commit prefect-dew

---
 prefect_huaweicloud/dew_block.py  | 978 ++++++++++++++++++++++++++++++
 prefect_huaweicloud/dew_client.py |  44 ++
 test_dew.py                       |  42 ++
 3 files changed, 1064 insertions(+)
 create mode 100644 prefect_huaweicloud/dew_block.py
 create mode 100644 prefect_huaweicloud/dew_client.py
 create mode 100644 test_dew.py

diff --git a/prefect_huaweicloud/dew_block.py b/prefect_huaweicloud/dew_block.py
new file mode 100644
index 0000000..d53488d
--- /dev/null
+++ b/prefect_huaweicloud/dew_block.py
@@ -0,0 +1,978 @@
+
+from typing import Any, Dict, List, Optional, Union
+from logging import Logger
+from pydantic import Field, SecretStr
+# from prefect import get_run_logger, task
+from prefect.blocks.abstract import SecretBlock
+from prefect.utilities.asyncutils import run_sync_in_worker_thread, sync_compatible
+from prefect.logging.loggers import get_logger, get_run_logger
+from prefect.exceptions import MissingContextError
+from prefect import task
+from pydantic import VERSION as PYDANTIC_VERSION
+import json
+if PYDANTIC_VERSION.startswith("2."):
+    from pydantic.v1 import Field
+else:
+    from pydantic import Field
+from prefect_huaweicloud.dew_client import DewClient
+# from obs import DewClient
+from  huaweicloudsdkkms.v2.model import *
+from huaweicloudsdkcore.exceptions import exceptions
+
+from huaweicloudsdkkms.v2.region.kms_region import KmsRegion
+from huaweicloudsdkkps.v3.region.kps_region import KpsRegion
+from huaweicloudsdkcsms.v1.region.csms_region import CsmsRegion
+from huaweicloudsdkcsms.v1 import *
+from huaweicloudsdkkms.v2 import *
+from huaweicloudsdkkps.v3 import *
+class DewBlock(SecretBlock):
+
+    _logo_url = "https://res-static.hc-cdn.cn/cloudbu-site/public/header-icon/Storage/OBS.png"  # noqa
+    _block_type_name = "HuaweiCloud DEW"
+    _documentation_url = ("https://support.huaweicloud.com/intl/zh-cn/sdk-python-devg-obs/obs_22_0100.html")  # noqa
+        
+    huawei_cloud_access_key_id: Optional[SecretStr] = Field(
+        default=None,
+        description="A specific Huawei Cloud access key ID.",
+        title="Huawei Cloud Access Key ID:",
+    )
+    huawei_cloud_secret_access_key: Optional[SecretStr] = Field(
+        default=None,
+        description="A specific Huawei Cloud secret access key.",
+        title="Huawei Cloud Access Key Secret:",
+        
+    )
+    huawei_cloud_security_token: Optional[SecretStr] = Field(
+        default=None,
+        description="SecurityToken in the temporary access key, "
+                    "You can select a temporary token or AK/SK for authentication",
+        title="Huawei Cloud Security Token",
+    )
+    region_id:Optional[str] = Field(
+        default=None,
+        title="region id",
+    )
+    def _get_dew_client(self) -> DewClient:
+        if not self.huawei_cloud_access_key_id or not self.huawei_cloud_secret_access_key:
+            raise Exception("please input both huawei_cloud_access_key_id and huawei_cloud_secret_access_key")
+
+        return DewClient(
+            ak=self.huawei_cloud_access_key_id.get_secret_value(),
+            sk=self.huawei_cloud_secret_access_key.get_secret_value(),
+            region_id=self.region_id,
+            )
+
+
+    @sync_compatible
+    async def read_secret(self,key_id:str=None,cipher_text:str=None,**kwargs):
+        
+        response =await run_sync_in_worker_thread(self._get_dew_client().decrypt_data_key, key_id,cipher_text,32)
+        if hasattr(response, 'status_code') and response.status_code==200:
+            self.logger.info(f"|status_code:200| The secret {key_id!r} data was successfully read.")
+        return response
+
+    @sync_compatible
+    async def write_secret(self,key_id:str=None,plain_text:str=None,**kwargs):        
+        global encrypt_data_key_response
+        if key_id is None :
+            new_key = await run_sync_in_worker_thread(self._get_dew_client().create_key,key_alias="new_key",key_spec="AES_256")
+            new_data_key = await run_sync_in_worker_thread(self._get_dew_client().create_data_key,new_key.key_id)
+            encrypt_data_key_response = await run_sync_in_worker_thread(self._get_dew_client().encrypt_data_key, new_key.key_id, plain_text or new_data_key.plain_text,32)
+     
+        elif plain_text is  None:
+            new_data_key =await run_sync_in_worker_thread(self._get_dew_client().create_data_key, key_id)
+            encrypt_data_key_response =await run_sync_in_worker_thread(self._get_dew_client().encrypt_data_key, key_id, new_data_key.plain_text,32)
+
+        else:
+            encrypt_data_key_response =await run_sync_in_worker_thread(self._get_dew_client().encrypt_data_key,key_id,plain_text,32)
+
+        if hasattr(encrypt_data_key_response, 'status_code') and encrypt_data_key_response.status_code==200:
+            self.logger.info(f"|status_code:200| The secret {key_id!r} data was successfully write.")
+        return encrypt_data_key_response
+        
+    @sync_compatible
+    async def delete_secret(self, key_id,pending_days,**kwargs):
+        
+        response =await run_sync_in_worker_thread(self._get_dew_client().delete_key,key_id=key_id,pending_days=pending_days)
+        if hasattr(response, 'status_code') and response.status_code==200:
+            self.logger.info(f"The secret {key_id} was deleted successfully.")
+        return response
+   
+    @property
+    def logger(self) -> Logger:
+        """
+        Returns a logger based on whether the ObjectStorageBlock
+        is called from within a flow or task run context.
+        If a run context is present, the logger property returns a run logger.
+        Else, it returns a default logger labeled with the class's name.
+
+        Returns:
+            The run logger or a default logger with the class's name.
+        """
+        try:
+            return get_run_logger()
+        except MissingContextError:
+            return get_logger(self.__class__.__name__)
+
+    def create_key(self,key_alias=None, key_spec=None, key_usage=None, key_description=None, origin=None, enterprise_project_id=None, sequence=None, keystore_id=None,**kwargs):
+        try:
+            request = CreateKeyRequest()
+            request.body = CreateKeyRequestBody(
+                key_alias=key_alias,
+                key_spec=key_spec,
+                key_usage=key_usage,
+                key_description=key_description,
+                origin=origin,
+                enterprise_project_id=enterprise_project_id,
+                sequence=sequence,
+                keystore_id=keystore_id
+            )
+            response =self._get_dew_client().kms_client.create_key(request)
+            self.logger.debug("Created key")
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    
+    def delete_key(self,key_id=None,pending_days=None, sequence=None,**kwargs):
+        try:
+            request = DeleteKeyRequest()
+            request.body = ScheduleKeyDeletionRequestBody(
+                key_id=key_id,
+                pending_days=pending_days,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.delete_key(request)
+            self.logger.debug("Successfully delete_key")
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def disable_key(self,key_id=None,sequence=None,**kwargs):
+        try:
+            request = DisableKeyRequest()
+            request.body = OperateKeyRequestBody(
+                key_id=key_id,
+                sequence=sequence
+            )
+            response =self._get_dew_client().kms_client.disable_key(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def enable_key(self,key_id=None, sequence=None,**kwargs):
+        try:
+            request = EnableKeyRequest()
+            request.body = OperateKeyRequestBody(
+                key_id=key_id,
+                sequence=sequence
+            )
+            response =self._get_dew_client().kms_client.enable_key(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def update_key_Alias(self,key_id=None, key_alias=None, sequence=None,**kwargs):
+        try:
+            request = UpdateKeyAliasRequest()
+            request.body = UpdateKeyAliasRequestBody(
+                key_alias=key_alias,
+                key_id=key_id,
+                sequence=sequence
+            )
+            response =self._get_dew_client().kms_client.update_key_alias(request)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def update_key_description(self,key_id=None, key_description=None, sequence=None,**kwargs):
+        try:
+            request = UpdateKeyDescriptionRequest()
+            request.body = UpdateKeyDescriptionRequestBody(
+                key_id=key_id,
+                key_description=key_description,
+                sequence=sequence
+            )
+            response =self._get_dew_client().kms_client.update_key_description(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def cancel_key_deletion(self,key_id=None,sequence=None,**kwargs):
+        try:
+            request = CancelKeyDeletionRequest()
+            request.body = OperateKeyRequestBody(
+                key_id=key_id,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.cancel_key_deletion(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+   
+    def create_data_key(self,key_id,key_spec=None, datakey_length=None, sequence=None,**kwargs):
+        try:
+            request = CreateDatakeyRequest()
+            request.body = CreateDatakeyRequestBody(
+                key_id=key_id,
+                key_spec=key_spec,
+                datakey_length=datakey_length,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.create_datakey(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def create_data_key_without_plaintext(self,key_id,key_spec=None, datakey_length=None, sequence=None,**kwargs):
+        try:
+            request = CreateDatakeyWithoutPlaintextRequest()
+            request.body = CreateDatakeyRequestBody(
+                key_id=key_id,
+                key_spec=key_spec,
+                datakey_length=datakey_length,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.create_datakey_without_plaintext(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def create_random(self,random_data_length=None, sequence=None,**kwargs):
+        try:
+            request = CreateRandomRequest()
+            request.body = GenRandomRequestBody(
+                random_data_length=random_data_length,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.create_random(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def decrypt_data_key(self,key_id=None, cipher_text=None, datakey_cipher_length=None, sequence=None,**kwargs):
+        try:
+            request = DecryptDatakeyRequest()
+            request.body = DecryptDatakeyRequestBody(
+                key_id=key_id,
+                cipher_text=cipher_text,
+                datakey_cipher_length=datakey_cipher_length,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.decrypt_datakey(request)
+            self.logger.info(response)
+            return response
+            
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def encrypt_data_key(self,key_id=None, plain_text=None, datakey_plain_length=None, sequence=None,**kwargs):
+        try:
+            request = EncryptDatakeyRequest()
+            request.body = EncryptDatakeyRequestBody(
+                key_id=key_id,
+                plain_text=plain_text,
+                datakey_plain_length=datakey_plain_length,
+                sequence=sequence
+
+            )
+            response = self._get_dew_client().kms_client.encrypt_datakey(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+
+    def create_parameters_for_import(self,key_id,wrapping_algorithm=None, sequence=None,**kwargs):
+        try:
+            request = CreateParametersForImportRequest()
+            request.body = GetParametersForImportRequestBody(
+                key_id=key_id,
+                wrapping_algorithm=wrapping_algorithm,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.create_parameters_for_import(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def delete_imported_key_material(self,key_id,sequence=None,**kwargs):
+        try:
+            request = DeleteImportedKeyMaterialRequest()
+            request.body = OperateKeyRequestBody(
+                key_id = key_id,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.delete_imported_key_material(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def import_key_material(self,key_id=None, import_token=None, encrypted_key_material=None, encrypted_privatekey=None, expiration_time=None, sequence=None,**kwargs):
+        try:
+            request = ImportKeyMaterialRequest()
+            request.body = ImportKeyMaterialRequestBody(
+                key_id=key_id,
+                import_token=import_token,
+                encrypted_key_material=encrypted_key_material,
+                encrypted_privatekey=encrypted_privatekey,
+                expiration_time=expiration_time,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.import_key_material(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    
+    def decrypt_data(self,cipher_text=None, encryption_algorithm=None, key_id=None, sequence=None,**kwargs):
+        try:
+            request = DecryptDataRequest()
+            request.body = DecryptDataRequestBody(
+                cipher_text=cipher_text,
+                encryption_algorithm=encryption_algorithm,
+                key_id=key_id,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.decrypt_data(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def encrypt_data(self,key_id=None,plain_text=None, encryption_algorithm=None, sequence=None,**kwargs):
+        try:
+            request = EncryptDataRequest()
+            request.body = EncryptDataRequestBody(
+                plain_text=plain_text,
+                key_id=key_id,
+                encryption_algorithm=encryption_algorithm,
+                sequence=sequence                
+            )
+            response = self._get_dew_client().kms_client.encrypt_data(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    
+    def list_key_detail(self,key_id=None,sequence=None,**kwargs):
+        try:
+            request = ListKeyDetailRequest()
+            request.body = OperateKeyRequestBody(
+                key_id=key_id,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.list_key_detail(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def list_keys(self,limit=None, marker=None, key_state=None, key_spec=None, enterprise_project_id=None, sequence=None,**kwargs):
+        try:
+            request = ListKeysRequest()
+            request.body = ListKeysRequestBody(
+                limit=limit,
+                marker=marker,
+                key_state=key_state,
+                key_spec=key_spec,
+                enterprise_project_id=enterprise_project_id,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.list_keys(request)
+            # print(response.to_dict())            
+            print(json.dumps(response.to_dict()).replace('}','}\n'))
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def show_public_key(self,key_id=None, sequence=None,**kwargs):
+        try:
+            request = ShowPublicKeyRequest()
+            request.body = OperateKeyRequestBody(
+                key_id=key_id, sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.show_public_key(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def show_user_instances(self,**kwargs):
+        try:
+            request = ShowUserInstancesRequest()
+            response = self._get_dew_client().kms_client.show_user_instances(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def show_user_quotas(self,**kwargs):
+        try:
+            request = ShowUserQuotasRequest()
+            response = self._get_dew_client().kms_client.show_user_quotas(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+
+    def show_version(self,**kwargs):
+        try:
+            request = ShowVersionRequest(kwargs)
+            response = self._get_dew_client().kms_client.show_version(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def show_versions(self,**kwargs):
+        try:
+            request = ShowVersionsRequest()
+            response = self._get_dew_client().kms_client.show_versions(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def create_keypair(self,name=None, type=None, public_key=None, scope=None, user_id=None, key_protection=None,**kwargs):
+        try:
+            request = CreateKeypairRequest()
+            keypairbody = CreateKeypairAction(
+                name=name,
+                type=type,
+                public_key=public_key,
+                scope=scope,
+                user_id=user_id,
+                key_protection=key_protection
+            )
+            request.body = CreateKeypairRequestBody(
+                keypair=keypairbody
+            )
+            response = self._get_dew_client().kps_client.create_keypair(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def list_keypairs(self,limit=None, marker=None,**kwargs):
+        try:
+            request = ListKeypairsRequest(
+                limit=limit,
+                marker=marker
+            )
+            response = self._get_dew_client().kps_client.list_keypairs(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def clear_private_key(self,keypair_name=None,**kwargs):
+        try:
+            request = ClearPrivateKeyRequest(keypair_name=keypair_name)
+            response = self._get_dew_client().kps_client.clear_private_key(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def import_private_key(self,user_id=None, name=None,type="default",kms_key_name="kps/default",private_key=None,**kwargs):
+        try:
+            request = ImportPrivateKeyRequest()
+            encryptionKeyProtection = Encryption(
+                type=type,
+                kms_key_name=kms_key_name
+            )
+            keyProtectionKeypair = ImportPrivateKeyProtection(
+                private_key=private_key,
+                encryption=encryptionKeyProtection
+            )
+            keypairbody  = ImportPrivateKeyKeypairBean(
+                name=name,
+                key_protection=keyProtectionKeypair,
+                user_id=user_id
+            )
+            request.body = ImportPrivateKeyRequestBody(
+                keypair=keypairbody
+            )
+            response = self._get_dew_client().kps_client.import_private_key(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def list_keypair_detail(self,keypair_name=None,**kwargs):
+        try:
+            request = ListKeypairDetailRequest(keypair_name=keypair_name)
+            response = self._get_dew_client().kps_client.list_keypair_detail(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def update_keypair_description(self,keypair_name=None,description=None,**kwargs):
+        try:
+            request = UpdateKeypairDescriptionRequest(
+                keypair_name=keypair_name
+            )
+            keypairbody = UpdateKeypairDescriptionReq(
+                description=description
+            )
+            request.body = UpdateKeypairDescriptionRequestBody(
+                keypair=keypairbody
+            )
+            response = self._get_dew_client().kps_client.update_keypair_description(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def export_private_key(self,name=None,**kwargs):
+        try:
+            request = ExportPrivateKeyRequest()
+            keypairbody = KeypairBean(
+                name=name
+            )
+            request.body = ExportPrivateKeyRequestBody(
+                keypair=keypairbody
+            )
+            response = self._get_dew_client().kps_client.export_private_key(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def delete_keypair(self,keypair_name=None,**kwargs):
+        try:
+            request = DeleteKeypairRequest(keypair_name=keypair_name)
+            response = self._get_dew_client().kps_client.delete_keypair(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def associate_keypair(self,keypair_name=None,type=None,key=None,id=None, disable_password=False, port=None,**kwargs):
+        try:
+            request = AssociateKeypairRequest()
+            authServer = Auth(
+                type=type,
+                key=key
+            )
+            serverbody = EcsServerInfo(
+                id=id,
+                auth=authServer,
+                disable_password=disable_password,
+                port=port
+            )
+            request.body = AssociateKeypairRequestBody(
+                server=serverbody,
+                keypair_name=keypair_name
+            )
+            response = self._get_dew_client().kps_client.associate_keypair(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def batch_associate_keypair(self,keypair_name=[],type=[],key=[],id=[],disable_password=[],port=[],**kwargs):
+        try:
+            request = BatchAssociateKeypairRequest()           
+            listBatchKeypairsbody = []
+            for s in range(len(keypair_name),**kwargs):
+                authServer = Auth(
+                    type=type[s],
+                    key=key[s]
+                )
+                serverBatchKeypairs = EcsServerInfo(
+                    id=id[s],
+                    auth=authServer,
+                    disable_password=disable_password[s],
+                    port=port[s]
+                )
+                listBatchKeypairsbody.append(AssociateKeypairRequestBody(
+                    keypair_name=keypair_name[s],
+                    server=serverBatchKeypairs
+                ))
+               
+            request.body = BatchAssociateKeypairRequestBody(
+                batch_keypairs=listBatchKeypairsbody
+            )
+            response = self._get_dew_client().kps_client.batch_associate_keypair(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def delete_all_failed_task(self,**kwargs):
+        try:
+            request = DeleteAllFailedTaskRequest()
+            response = self._get_dew_client().kps_client.delete_all_failed_task(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def delete_failed_task(self,task_id,**kwargs):
+        try:
+            request = DeleteFailedTaskRequest(
+                task_id=task_id,                
+            )
+            response = self._get_dew_client().kps_client.delete_failed_task(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def disassociate_keypair(self,id=None,type=None,key=None,**kwargs):
+        try:
+            request = DisassociateKeypairRequest()
+            authServer = Auth(
+                    type=type,
+                    key=key
+                )
+            serverbody = DisassociateEcsServerInfo(
+                id=id,
+                auth=authServer
+            )
+            request.body = DisassociateKeypairRequestBody(
+                server=serverbody
+            )
+            response = self._get_dew_client().kps_client.disassociate_keypair(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def list_failed_task(self,limit=None, offset=None,**kwargs):
+        try:
+            request = ListFailedTaskRequest()
+            request.limit = limit
+            request.offset = offset
+            response = self._get_dew_client().kps_client.list_failed_task(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def list_keypair_task(self,task_id=None,**kwargs):
+        try:
+            request = ListKeypairTaskRequest(
+                task_id=task_id
+            )
+            response = self._get_dew_client().kps_client.list_keypair_task(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def list_running_task(self,limit=None,offset=None,**kwargs):
+        try:
+            request = ListRunningTaskRequest()
+            request.limit = limit
+            request.offset = offset
+            response = self._get_dew_client().kps_client.list_running_task(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def create_secret(self,name=None, kms_key_id=None, description=None, secret_binary=None, secret_string=None, secret_type=None, auto_rotation=None, rotation_period=None, rotation_config=None, event_subscriptions=None, enterprise_project_id=None,**kwargs):
+        try:
+            request = CreateSecretRequest()
+            request.body = CreateSecretRequestBody(
+                secret_string=secret_string,
+                kms_key_id=kms_key_id,
+                name=name,
+                description=description,
+                secret_binary=secret_binary,
+                secret_type=secret_type,
+                auto_rotation=auto_rotation,
+                rotation_period=rotation_period,
+                rotation_config=rotation_config,
+                event_subscriptions=event_subscriptions,
+                enterprise_project_id=enterprise_project_id
+            )
+            response = self._get_dew_client().cms_client.create_secret(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def download_secret_blob(self,secret_name:None,**kwargs):
+        try:
+            request = DownloadSecretBlobRequest(
+                secret_name=secret_name
+            )
+            response = self._get_dew_client().cms_client.download_secret_blob(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def list_secrets(self,limit=None,marker=None,event_name=None,**kwargs):
+        try:
+            request = ListSecretsRequest()
+            request.limit = limit
+            request.marker = marker
+            request.event_name = event_name
+            response = self._get_dew_client().cms_client.list_secrets(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def show_secret(self,secret_name,**kwargs):
+        try:
+            request = ShowSecretRequest(
+                secret_name=secret_name
+            )
+            response = self._get_dew_client().cms_client.show_secret(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def update_secret(self,kms_key_id=None,secret_name=None, description=None, auto_rotation=None, rotation_period=None, listEventSubscriptionsbody=None,**kwargs):
+        try:
+            request = UpdateSecretRequest()
+            request.body = UpdateSecretRequestBody(
+                event_subscriptions=listEventSubscriptionsbody,
+                description=description,
+                kms_key_id=kms_key_id,                
+                auto_rotation=auto_rotation,
+                rotation_period=rotation_period,
+            )
+            request.secret_name=secret_name
+            response = self._get_dew_client().cms_client.update_secret(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def create_secret_event(self,target_type=None, target_id=None, target_name=None,name=None, state=None, listEventTypesbody=[],**kwargs):
+        try:
+            request = CreateSecretEventRequest()
+            notificationbody = Notification(
+                target_type=target_type,
+                target_id=target_id,
+                target_name=target_name
+            )
+            request.body = CreateSecretEventRequestBody(
+                notification=notificationbody,
+                state=state,
+                event_types=listEventTypesbody,
+                name=name,
+            )
+            response = self._get_dew_client().cms_client.create_secret_event(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def upload_secret_blob(self,secret_blob,**kwargs):
+        try:
+            request = UploadSecretBlobRequest()
+            request.body = UploadSecretBlobRequestBody(
+                secret_blob=secret_blob
+            )
+            response = self._get_dew_client().cms_client.upload_secret_blob(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            print(e.status_code)
+            print(e.request_id)
+            print(e.error_code)
+    def rotate_secret(self,secret_name=None,**kwargs):
+        try:
+            request = RotateSecretRequest(
+                secret_name=secret_name
+            )
+            response = self._get_dew_client().cms_client.rotate_secret(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def restore_secret(self,secret_name,**kwargs):
+        try:
+            request = RestoreSecretRequest(secret_name=secret_name)
+            response = self._get_dew_client().cms_client.restore_secret(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def delete_secret_for_schedule(self,recovery_window_in_days=None,secret_name=None,**kwargs):
+        try:
+            request = DeleteSecretForScheduleRequest(secret_name=secret_name)
+            request.body = DeleteSecretForScheduleRequestBody(
+                recovery_window_in_days=recovery_window_in_days
+            )
+            response = self._get_dew_client().cms_client.delete_secret_for_schedule(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def delete_secret(self,secret_name,**kwargs):
+        try:
+            request = DeleteSecretRequest(secret_name=secret_name)
+            response = self._get_dew_client().cms_client.delete_secret(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    
+    def create_secret_version(self,secret_name=None,secret_binary=None, secret_string=None, version_stages=None, expire_time=None,**kwargs):
+        try:
+            request = CreateSecretVersionRequest(secret_name=secret_name)
+            request.body = CreateSecretVersionRequestBody(
+                secret_string=secret_string,
+                secret_binary=secret_binary,
+                version_stages=version_stages,
+                expire_time=expire_time
+            )
+            response = self._get_dew_client().cms_client.create_secret_version(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def list_secret_versions(self,secret_name=None, marker=None, limit=None,**kwargs):   
+        try:
+            request = ListSecretVersionsRequest()
+            request.secret_name = secret_name
+            request.marker = marker
+            request.limit = limit
+            response = self._get_dew_client().cms_client.list_secret_versions(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+
+    def show_secret_version(self,secret_name=None,version_id=None,**kwargs):
+        try:
+            request = ShowSecretVersionRequest()
+            request.secret_name=secret_name
+            request.version_id = version_id
+            response = self._get_dew_client().cms_client.show_secret_version(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def update_version(self,secret_name=None, version_id=None, expire_time=None,**kwargs):
+        try:
+            request = UpdateVersionRequest()
+            request.version_id=version_id
+            request.secret_name=secret_name
+            request.body = UpdateVersionRequestBody(
+                expire_time=expire_time
+            )
+            response = self._get_dew_client().cms_client.update_version(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+            
+
diff --git a/prefect_huaweicloud/dew_client.py b/prefect_huaweicloud/dew_client.py
new file mode 100644
index 0000000..cfd22f1
--- /dev/null
+++ b/prefect_huaweicloud/dew_client.py
@@ -0,0 +1,44 @@
+from huaweicloudsdkcore.auth.credentials import BasicCredentials
+from huaweicloudsdkcore.exceptions import exceptions
+from huaweicloudsdkkms.v2.region.kms_region import KmsRegion
+from huaweicloudsdkkms.v2 import *
+from huaweicloudsdkkps.v3.region.kps_region import KpsRegion
+from huaweicloudsdkkps.v3 import *
+from huaweicloudsdkcsms.v1.region.csms_region import CsmsRegion
+from huaweicloudsdkcsms.v1 import *
+from typing import Any, Coroutine, Dict, List, Optional, Union
+
+from prefect import get_run_logger, task
+from prefect.blocks.abstract import SecretBlock
+from prefect.utilities.asyncutils import run_sync_in_worker_thread, sync_compatible
+from pydantic import VERSION as PYDANTIC_VERSION
+import json
+if PYDANTIC_VERSION.startswith("2."):
+    from pydantic.v1 import Field
+else:
+    from pydantic import Field
+class DewClient():
+    def __init__(self,region_id:str,ak:str,sk:str):
+        self.region_id=region_id
+        self.__ak=ak
+        self.__sk=sk
+    @property
+    def kms_client(self)->KmsClient:
+        return KmsClient.new_builder() \
+            .with_credentials(BasicCredentials(self.__ak,self.__sk)) \
+            .with_region(KmsRegion.value_of(self.region_id)) \
+            .build()
+    @property
+    def kps_client(self)->KpsClient:        
+        return KpsClient.new_builder() \
+            .with_credentials(BasicCredentials(self.__ak,self.__sk)) \
+            .with_region(KpsRegion.value_of(self.region_id)) \
+            .build()
+    @property
+    def cms_client(self)->CsmsClient:    
+        return CsmsClient.new_builder() \
+            .with_credentials(BasicCredentials(self.__ak,self.__sk)) \
+            .with_region(CsmsRegion.value_of(self.region_id)) \
+            .build()
+    
+    
\ No newline at end of file
diff --git a/test_dew.py b/test_dew.py
new file mode 100644
index 0000000..c5c48ef
--- /dev/null
+++ b/test_dew.py
@@ -0,0 +1,42 @@
+from prefect_huaweicloud.dew_block import DewBlock
+from contextlib import redirect_stdout  
+import asyncio
+from prefect import flow,task,Task
+import pytest
+
+
+
+def test_list_keys(test_huaweicloud_dew_block):
+    test_huaweicloud_dew_block.list_keys()
+
+def kms_key_under_test(huaweicloud_dew_block,key_alias=None):
+     test_key=huaweicloud_dew_block.create_key(key_alias=key_alias)
+     return dict(
+          key_alias=key_alias,
+          key_id=test_key.key_info.key_id,
+          key_description=None,
+          pending_days=7
+     )
+
+@flow
+def test_key_lifecycle_management(kms_key_under_test,huaweicloud_dew_block):
+     row_key_alias=kms_key_under_test['key_alias']
+     huaweicloud_dew_block.create_key(**kms_key_under_test)
+     huaweicloud_dew_block.disable_key(**kms_key_under_test)
+     huaweicloud_dew_block.enable_key(**kms_key_under_test)
+     kms_key_under_test['key_alias']="test_alias"
+     huaweicloud_dew_block.update_key_Alias(**kms_key_under_test)
+     kms_key_under_test['key_alias']=row_key_alias
+     huaweicloud_dew_block.update_key_Alias(**kms_key_under_test)
+     kms_key_under_test['key_description']="test_update_description"
+     huaweicloud_dew_block.update_key_description(**kms_key_under_test)
+     huaweicloud_dew_block.delete_key(**kms_key_under_test)     
+     huaweicloud_dew_block.cancel_key_deletion(**kms_key_under_test)
+     huaweicloud_dew_block.enable_key(**kms_key_under_test)
+
+     
+
+
+if __name__=="__main__":
+    huaweicloud_dew_block = DewBlock.load("test-dew-block")
+    test_key_lifecycle_management(kms_key_under_test(huaweicloud_dew_block,key_alias="12-26"),huaweicloud_dew_block)
\ No newline at end of file
-- 
Gitee


From ed71f9ca74fccca7930a70e4546aa9c1ddf8e8bb Mon Sep 17 00:00:00 2001
From: lky <523175094@qq.com>
Date: Tue, 26 Dec 2023 06:41:07 +0000
Subject: [PATCH 3/4] first commit prefect-dew

Signed-off-by: lky <523175094@qq.com>
---
 dew_block.py  | 978 ++++++++++++++++++++++++++++++++++++++++++++++++++
 dew_client.py |  44 +++
 test_dew.py   |  42 +++
 3 files changed, 1064 insertions(+)
 create mode 100644 dew_block.py
 create mode 100644 dew_client.py
 create mode 100644 test_dew.py

diff --git a/dew_block.py b/dew_block.py
new file mode 100644
index 0000000..21b1a6a
--- /dev/null
+++ b/dew_block.py
@@ -0,0 +1,978 @@
+
+from typing import Any, Dict, List, Optional, Union
+from logging import Logger
+from pydantic import Field, SecretStr
+# from prefect import get_run_logger, task
+from prefect.blocks.abstract import SecretBlock
+from prefect.utilities.asyncutils import run_sync_in_worker_thread, sync_compatible
+from prefect.logging.loggers import get_logger, get_run_logger
+from prefect.exceptions import MissingContextError
+from prefect import task
+from pydantic import VERSION as PYDANTIC_VERSION
+import json
+if PYDANTIC_VERSION.startswith("2."):
+    from pydantic.v1 import Field
+else:
+    from pydantic import Field
+from prefect_huaweicloud.dew_client import DewClient
+# from obs import DewClient
+from  huaweicloudsdkkms.v2.model import *
+from huaweicloudsdkcore.exceptions import exceptions
+
+from huaweicloudsdkkms.v2.region.kms_region import KmsRegion
+from huaweicloudsdkkps.v3.region.kps_region import KpsRegion
+from huaweicloudsdkcsms.v1.region.csms_region import CsmsRegion
+from huaweicloudsdkcsms.v1 import *
+from huaweicloudsdkkms.v2 import *
+from huaweicloudsdkkps.v3 import *
+class DewBlock(SecretBlock):
+
+    _logo_url = "https://res-static.hc-cdn.cn/cloudbu-site/public/header-icon/Storage/OBS.png"  # noqa
+    _block_type_name = "HuaweiCloud DEW"
+    _documentation_url = ("https://support.huaweicloud.com/intl/zh-cn/sdk-python-devg-obs/obs_22_0100.html")  # noqa
+        
+    huawei_cloud_access_key_id: Optional[SecretStr] = Field(
+        default=None,
+        description="A specific Huawei Cloud access key ID.",
+        title="Huawei Cloud Access Key ID:",
+    )
+    huawei_cloud_secret_access_key: Optional[SecretStr] = Field(
+        default=None,
+        description="A specific Huawei Cloud secret access key.",
+        title="Huawei Cloud Access Key Secret:",
+        
+    )
+    huawei_cloud_security_token: Optional[SecretStr] = Field(
+        default=None,
+        description="SecurityToken in the temporary access key, "
+                    "You can select a temporary token or AK/SK for authentication",
+        title="Huawei Cloud Security Token",
+    )
+    region_id:Optional[str] = Field(
+        default=None,
+        title="region id",
+    )
+    def _get_dew_client(self) -> DewClient:
+        if not self.huawei_cloud_access_key_id or not self.huawei_cloud_secret_access_key:
+            raise Exception("please input both huawei_cloud_access_key_id and huawei_cloud_secret_access_key")
+
+        return DewClient(
+            ak=self.huawei_cloud_access_key_id.get_secret_value(),
+            sk=self.huawei_cloud_secret_access_key.get_secret_value(),
+            region_id=self.region_id,
+            )
+
+
+    @sync_compatible
+    async def read_secret(self,key_id:str=None,cipher_text:str=None,**kwargs):
+        
+        response =await run_sync_in_worker_thread(self._get_dew_client().decrypt_data_key, key_id,cipher_text,32)
+        if hasattr(response, 'status_code') and response.status_code==200:
+            self.logger.info(f"|status_code:200| The secret {key_id!r} data was successfully read.")
+        return response
+
+    @sync_compatible
+    async def write_secret(self,key_id:str=None,plain_text:str=None,**kwargs):        
+        global encrypt_data_key_response
+        if key_id is None :
+            new_key = await run_sync_in_worker_thread(self._get_dew_client().create_key,key_alias="new_key",key_spec="AES_256")
+            new_data_key = await run_sync_in_worker_thread(self._get_dew_client().create_data_key,new_key.key_id)
+            encrypt_data_key_response = await run_sync_in_worker_thread(self._get_dew_client().encrypt_data_key, new_key.key_id, plain_text or new_data_key.plain_text,32)
+     
+        elif plain_text is  None:
+            new_data_key =await run_sync_in_worker_thread(self._get_dew_client().create_data_key, key_id)
+            encrypt_data_key_response =await run_sync_in_worker_thread(self._get_dew_client().encrypt_data_key, key_id, new_data_key.plain_text,32)
+
+        else:
+            encrypt_data_key_response =await run_sync_in_worker_thread(self._get_dew_client().encrypt_data_key,key_id,plain_text,32)
+
+        if hasattr(encrypt_data_key_response, 'status_code') and encrypt_data_key_response.status_code==200:
+            self.logger.info(f"|status_code:200| The secret {key_id!r} data was successfully write.")
+        return encrypt_data_key_response
+        
+    @sync_compatible
+    async def delete_secret(self, key_id,pending_days,**kwargs):
+        
+        response =await run_sync_in_worker_thread(self._get_dew_client().delete_key,key_id=key_id,pending_days=pending_days)
+        if hasattr(response, 'status_code') and response.status_code==200:
+            self.logger.info(f"The secret {key_id} was deleted successfully.")
+        return response
+   
+    @property
+    def logger(self) -> Logger:
+        """
+        Returns a logger based on whether the ObjectStorageBlock
+        is called from within a flow or task run context.
+        If a run context is present, the logger property returns a run logger.
+        Else, it returns a default logger labeled with the class's name.
+
+        Returns:
+            The run logger or a default logger with the class's name.
+        """
+        try:
+            return get_run_logger()
+        except MissingContextError:
+            return get_logger(self.__class__.__name__)
+
+    def create_key(self,key_alias=None, key_spec=None, key_usage=None, key_description=None, origin=None, enterprise_project_id=None, sequence=None, keystore_id=None,**kwargs):
+        try:
+            request = CreateKeyRequest()
+            request.body = CreateKeyRequestBody(
+                key_alias=key_alias,
+                key_spec=key_spec,
+                key_usage=key_usage,
+                key_description=key_description,
+                origin=origin,
+                enterprise_project_id=enterprise_project_id,
+                sequence=sequence,
+                keystore_id=keystore_id
+            )
+            response =self._get_dew_client().kms_client.create_key(request)
+            self.logger.debug("Created key")
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    
+    def delete_key(self,key_id=None,pending_days=None, sequence=None,**kwargs):
+        try:
+            request = DeleteKeyRequest()
+            request.body = ScheduleKeyDeletionRequestBody(
+                key_id=key_id,
+                pending_days=pending_days,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.delete_key(request)
+            self.logger.debug("Successfully delete_key")
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def disable_key(self,key_id=None,sequence=None,**kwargs):
+        try:
+            request = DisableKeyRequest()
+            request.body = OperateKeyRequestBody(
+                key_id=key_id,
+                sequence=sequence
+            )
+            response =self._get_dew_client().kms_client.disable_key(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def enable_key(self,key_id=None, sequence=None,**kwargs):
+        try:
+            request = EnableKeyRequest()
+            request.body = OperateKeyRequestBody(
+                key_id=key_id,
+                sequence=sequence
+            )
+            response =self._get_dew_client().kms_client.enable_key(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def update_key_Alias(self,key_id=None, key_alias=None, sequence=None,**kwargs):
+        try:
+            request = UpdateKeyAliasRequest()
+            request.body = UpdateKeyAliasRequestBody(
+                key_alias=key_alias,
+                key_id=key_id,
+                sequence=sequence
+            )
+            response =self._get_dew_client().kms_client.update_key_alias(request)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def update_key_description(self,key_id=None, key_description=None, sequence=None,**kwargs):
+        try:
+            request = UpdateKeyDescriptionRequest()
+            request.body = UpdateKeyDescriptionRequestBody(
+                key_id=key_id,
+                key_description=key_description,
+                sequence=sequence
+            )
+            response =self._get_dew_client().kms_client.update_key_description(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def cancel_key_deletion(self,key_id=None,sequence=None,**kwargs):
+        try:
+            request = CancelKeyDeletionRequest()
+            request.body = OperateKeyRequestBody(
+                key_id=key_id,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.cancel_key_deletion(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+   
+    def create_data_key(self,key_id,key_spec=None, datakey_length=None, sequence=None,**kwargs):
+        try:
+            request = CreateDatakeyRequest()
+            request.body = CreateDatakeyRequestBody(
+                key_id=key_id,
+                key_spec=key_spec,
+                datakey_length=datakey_length,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.create_datakey(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def create_data_key_without_plaintext(self,key_id,key_spec=None, datakey_length=None, sequence=None,**kwargs):
+        try:
+            request = CreateDatakeyWithoutPlaintextRequest()
+            request.body = CreateDatakeyRequestBody(
+                key_id=key_id,
+                key_spec=key_spec,
+                datakey_length=datakey_length,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.create_datakey_without_plaintext(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def create_random(self,random_data_length=None, sequence=None,**kwargs):
+        try:
+            request = CreateRandomRequest()
+            request.body = GenRandomRequestBody(
+                random_data_length=random_data_length,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.create_random(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def decrypt_data_key(self,key_id=None, cipher_text=None, datakey_cipher_length=None, sequence=None,**kwargs):
+        try:
+            request = DecryptDatakeyRequest()
+            request.body = DecryptDatakeyRequestBody(
+                key_id=key_id,
+                cipher_text=cipher_text,
+                datakey_cipher_length=datakey_cipher_length,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.decrypt_datakey(request)
+            self.logger.info(response)
+            return response
+            
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def encrypt_data_key(self,key_id=None, plain_text=None, datakey_plain_length=None, sequence=None,**kwargs):
+        try:
+            request = EncryptDatakeyRequest()
+            request.body = EncryptDatakeyRequestBody(
+                key_id=key_id,
+                plain_text=plain_text,
+                datakey_plain_length=datakey_plain_length,
+                sequence=sequence
+
+            )
+            response = self._get_dew_client().kms_client.encrypt_datakey(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+
+    def create_parameters_for_import(self,key_id,wrapping_algorithm=None, sequence=None,**kwargs):
+        try:
+            request = CreateParametersForImportRequest()
+            request.body = GetParametersForImportRequestBody(
+                key_id=key_id,
+                wrapping_algorithm=wrapping_algorithm,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.create_parameters_for_import(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def delete_imported_key_material(self,key_id,sequence=None,**kwargs):
+        try:
+            request = DeleteImportedKeyMaterialRequest()
+            request.body = OperateKeyRequestBody(
+                key_id = key_id,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.delete_imported_key_material(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def import_key_material(self,key_id=None, import_token=None, encrypted_key_material=None, encrypted_privatekey=None, expiration_time=None, sequence=None,**kwargs):
+        try:
+            request = ImportKeyMaterialRequest()
+            request.body = ImportKeyMaterialRequestBody(
+                key_id=key_id,
+                import_token=import_token,
+                encrypted_key_material=encrypted_key_material,
+                encrypted_privatekey=encrypted_privatekey,
+                expiration_time=expiration_time,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.import_key_material(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    
+    def decrypt_data(self,cipher_text=None, encryption_algorithm=None, key_id=None, sequence=None,**kwargs):
+        try:
+            request = DecryptDataRequest()
+            request.body = DecryptDataRequestBody(
+                cipher_text=cipher_text,
+                encryption_algorithm=encryption_algorithm,
+                key_id=key_id,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.decrypt_data(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def encrypt_data(self,key_id=None,plain_text=None, encryption_algorithm=None, sequence=None,**kwargs):
+        try:
+            request = EncryptDataRequest()
+            request.body = EncryptDataRequestBody(
+                plain_text=plain_text,
+                key_id=key_id,
+                encryption_algorithm=encryption_algorithm,
+                sequence=sequence                
+            )
+            response = self._get_dew_client().kms_client.encrypt_data(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    
+    def list_key_detail(self,key_id=None,sequence=None,**kwargs):
+        try:
+            request = ListKeyDetailRequest()
+            request.body = OperateKeyRequestBody(
+                key_id=key_id,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.list_key_detail(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def list_keys(self,limit=None, marker=None, key_state=None, key_spec=None, enterprise_project_id=None, sequence=None,**kwargs):
+        try:
+            request = ListKeysRequest()
+            request.body = ListKeysRequestBody(
+                limit=limit,
+                marker=marker,
+                key_state=key_state,
+                key_spec=key_spec,
+                enterprise_project_id=enterprise_project_id,
+                sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.list_keys(request)
+            # print(response.to_dict())            
+            print(json.dumps(response.to_dict()).replace('}','}\n'))
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def show_public_key(self,key_id=None, sequence=None,**kwargs):
+        try:
+            request = ShowPublicKeyRequest()
+            request.body = OperateKeyRequestBody(
+                key_id=key_id, sequence=sequence
+            )
+            response = self._get_dew_client().kms_client.show_public_key(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def show_user_instances(self,**kwargs):
+        try:
+            request = ShowUserInstancesRequest()
+            response = self._get_dew_client().kms_client.show_user_instances(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def show_user_quotas(self,**kwargs):
+        try:
+            request = ShowUserQuotasRequest()
+            response = self._get_dew_client().kms_client.show_user_quotas(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+
+    def show_version(self,**kwargs):
+        try:
+            request = ShowVersionRequest(kwargs)
+            response = self._get_dew_client().kms_client.show_version(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def show_versions(self,**kwargs):
+        try:
+            request = ShowVersionsRequest()
+            response = self._get_dew_client().kms_client.show_versions(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def create_keypair(self,name=None, type=None, public_key=None, scope=None, user_id=None, key_protection=None,**kwargs):
+        try:
+            request = CreateKeypairRequest()
+            keypairbody = CreateKeypairAction(
+                name=name,
+                type=type,
+                public_key=public_key,
+                scope=scope,
+                user_id=user_id,
+                key_protection=key_protection
+            )
+            request.body = CreateKeypairRequestBody(
+                keypair=keypairbody
+            )
+            response = self._get_dew_client().kps_client.create_keypair(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def list_keypairs(self,limit=None, marker=None,**kwargs):
+        try:
+            request = ListKeypairsRequest(
+                limit=limit,
+                marker=marker
+            )
+            response = self._get_dew_client().kps_client.list_keypairs(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def clear_private_key(self,keypair_name=None,**kwargs):
+        try:
+            request = ClearPrivateKeyRequest(keypair_name=keypair_name)
+            response = self._get_dew_client().kps_client.clear_private_key(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def import_private_key(self,user_id=None, name=None,type="default",kms_key_name="kps/default",private_key=None,**kwargs):
+        try:
+            request = ImportPrivateKeyRequest()
+            encryptionKeyProtection = Encryption(
+                type=type,
+                kms_key_name=kms_key_name
+            )
+            keyProtectionKeypair = ImportPrivateKeyProtection(
+                private_key=private_key,
+                encryption=encryptionKeyProtection
+            )
+            keypairbody  = ImportPrivateKeyKeypairBean(
+                name=name,
+                key_protection=keyProtectionKeypair,
+                user_id=user_id
+            )
+            request.body = ImportPrivateKeyRequestBody(
+                keypair=keypairbody
+            )
+            response = self._get_dew_client().kps_client.import_private_key(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def list_keypair_detail(self,keypair_name=None,**kwargs):
+        try:
+            request = ListKeypairDetailRequest(keypair_name=keypair_name)
+            response = self._get_dew_client().kps_client.list_keypair_detail(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def update_keypair_description(self,keypair_name=None,description=None,**kwargs):
+        try:
+            request = UpdateKeypairDescriptionRequest(
+                keypair_name=keypair_name
+            )
+            keypairbody = UpdateKeypairDescriptionReq(
+                description=description
+            )
+            request.body = UpdateKeypairDescriptionRequestBody(
+                keypair=keypairbody
+            )
+            response = self._get_dew_client().kps_client.update_keypair_description(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def export_private_key(self,name=None,**kwargs):
+        try:
+            request = ExportPrivateKeyRequest()
+            keypairbody = KeypairBean(
+                name=name
+            )
+            request.body = ExportPrivateKeyRequestBody(
+                keypair=keypairbody
+            )
+            response = self._get_dew_client().kps_client.export_private_key(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def delete_keypair(self,keypair_name=None,**kwargs):
+        try:
+            request = DeleteKeypairRequest(keypair_name=keypair_name)
+            response = self._get_dew_client().kps_client.delete_keypair(request)
+            self.logger.info(response)
+            return response
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def associate_keypair(self,keypair_name=None,type=None,key=None,id=None, disable_password=False, port=None,**kwargs):
+        try:
+            request = AssociateKeypairRequest()
+            authServer = Auth(
+                type=type,
+                key=key
+            )
+            serverbody = EcsServerInfo(
+                id=id,
+                auth=authServer,
+                disable_password=disable_password,
+                port=port
+            )
+            request.body = AssociateKeypairRequestBody(
+                server=serverbody,
+                keypair_name=keypair_name
+            )
+            response = self._get_dew_client().kps_client.associate_keypair(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def batch_associate_keypair(self,keypair_name=[],type=[],key=[],id=[],disable_password=[],port=[],**kwargs):
+        try:
+            request = BatchAssociateKeypairRequest()           
+            listBatchKeypairsbody = []
+            for s in range(len(keypair_name),**kwargs):
+                authServer = Auth(
+                    type=type[s],
+                    key=key[s]
+                )
+                serverBatchKeypairs = EcsServerInfo(
+                    id=id[s],
+                    auth=authServer,
+                    disable_password=disable_password[s],
+                    port=port[s]
+                )
+                listBatchKeypairsbody.append(AssociateKeypairRequestBody(
+                    keypair_name=keypair_name[s],
+                    server=serverBatchKeypairs
+                ))
+               
+            request.body = BatchAssociateKeypairRequestBody(
+                batch_keypairs=listBatchKeypairsbody
+            )
+            response = self._get_dew_client().kps_client.batch_associate_keypair(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def delete_all_failed_task(self,**kwargs):
+        try:
+            request = DeleteAllFailedTaskRequest()
+            response = self._get_dew_client().kps_client.delete_all_failed_task(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def delete_failed_task(self,task_id,**kwargs):
+        try:
+            request = DeleteFailedTaskRequest(
+                task_id=task_id,                
+            )
+            response = self._get_dew_client().kps_client.delete_failed_task(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def disassociate_keypair(self,id=None,type=None,key=None,**kwargs):
+        try:
+            request = DisassociateKeypairRequest()
+            authServer = Auth(
+                    type=type,
+                    key=key
+                )
+            serverbody = DisassociateEcsServerInfo(
+                id=id,
+                auth=authServer
+            )
+            request.body = DisassociateKeypairRequestBody(
+                server=serverbody
+            )
+            response = self._get_dew_client().kps_client.disassociate_keypair(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def list_failed_task(self,limit=None, offset=None,**kwargs):
+        try:
+            request = ListFailedTaskRequest()
+            request.limit = limit
+            request.offset = offset
+            response = self._get_dew_client().kps_client.list_failed_task(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def list_keypair_task(self,task_id=None,**kwargs):
+        try:
+            request = ListKeypairTaskRequest(
+                task_id=task_id
+            )
+            response = self._get_dew_client().kps_client.list_keypair_task(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def list_running_task(self,limit=None,offset=None,**kwargs):
+        try:
+            request = ListRunningTaskRequest()
+            request.limit = limit
+            request.offset = offset
+            response = self._get_dew_client().kps_client.list_running_task(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def create_secret(self,name=None, kms_key_id=None, description=None, secret_binary=None, secret_string=None, secret_type=None, auto_rotation=None, rotation_period=None, rotation_config=None, event_subscriptions=None, enterprise_project_id=None,**kwargs):
+        try:
+            request = CreateSecretRequest()
+            request.body = CreateSecretRequestBody(
+                secret_string=secret_string,
+                kms_key_id=kms_key_id,
+                name=name,
+                description=description,
+                secret_binary=secret_binary,
+                secret_type=secret_type,
+                auto_rotation=auto_rotation,
+                rotation_period=rotation_period,
+                rotation_config=rotation_config,
+                event_subscriptions=event_subscriptions,
+                enterprise_project_id=enterprise_project_id
+            )
+            response = self._get_dew_client().cms_client.create_secret(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def download_secret_blob(self,secret_name:None,**kwargs):
+        try:
+            request = DownloadSecretBlobRequest(
+                secret_name=secret_name
+            )
+            response = self._get_dew_client().cms_client.download_secret_blob(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def list_secrets(self,limit=None,marker=None,event_name=None,**kwargs):
+        try:
+            request = ListSecretsRequest()
+            request.limit = limit
+            request.marker = marker
+            request.event_name = event_name
+            response = self._get_dew_client().cms_client.list_secrets(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def show_secret(self,secret_name,**kwargs):
+        try:
+            request = ShowSecretRequest(
+                secret_name=secret_name
+            )
+            response = self._get_dew_client().cms_client.show_secret(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def update_secret(self,kms_key_id=None,secret_name=None, description=None, auto_rotation=None, rotation_period=None, listEventSubscriptionsbody=None,**kwargs):
+        try:
+            request = UpdateSecretRequest()
+            request.body = UpdateSecretRequestBody(
+                event_subscriptions=listEventSubscriptionsbody,
+                description=description,
+                kms_key_id=kms_key_id,                
+                auto_rotation=auto_rotation,
+                rotation_period=rotation_period,
+            )
+            request.secret_name=secret_name
+            response = self._get_dew_client().cms_client.update_secret(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def create_secret_event(self,target_type=None, target_id=None, target_name=None,name=None, state=None, listEventTypesbody=[],**kwargs):
+        try:
+            request = CreateSecretEventRequest()
+            notificationbody = Notification(
+                target_type=target_type,
+                target_id=target_id,
+                target_name=target_name
+            )
+            request.body = CreateSecretEventRequestBody(
+                notification=notificationbody,
+                state=state,
+                event_types=listEventTypesbody,
+                name=name,
+            )
+            response = self._get_dew_client().cms_client.create_secret_event(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def upload_secret_blob(self,secret_blob,**kwargs):
+        try:
+            request = UploadSecretBlobRequest()
+            request.body = UploadSecretBlobRequestBody(
+                secret_blob=secret_blob
+            )
+            response = self._get_dew_client().cms_client.upload_secret_blob(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            print(e.status_code)
+            print(e.request_id)
+            print(e.error_code)
+    def rotate_secret(self,secret_name=None,**kwargs):
+        try:
+            request = RotateSecretRequest(
+                secret_name=secret_name
+            )
+            response = self._get_dew_client().cms_client.rotate_secret(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def restore_secret(self,secret_name,**kwargs):
+        try:
+            request = RestoreSecretRequest(secret_name=secret_name)
+            response = self._get_dew_client().cms_client.restore_secret(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def delete_secret_for_schedule(self,recovery_window_in_days=None,secret_name=None,**kwargs):
+        try:
+            request = DeleteSecretForScheduleRequest(secret_name=secret_name)
+            request.body = DeleteSecretForScheduleRequestBody(
+                recovery_window_in_days=recovery_window_in_days
+            )
+            response = self._get_dew_client().cms_client.delete_secret_for_schedule(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def delete_secret(self,secret_name,**kwargs):
+        try:
+            request = DeleteSecretRequest(secret_name=secret_name)
+            response = self._get_dew_client().cms_client.delete_secret(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    
+    def create_secret_version(self,secret_name=None,secret_binary=None, secret_string=None, version_stages=None, expire_time=None,**kwargs):
+        try:
+            request = CreateSecretVersionRequest(secret_name=secret_name)
+            request.body = CreateSecretVersionRequestBody(
+                secret_string=secret_string,
+                secret_binary=secret_binary,
+                version_stages=version_stages,
+                expire_time=expire_time
+            )
+            response = self._get_dew_client().cms_client.create_secret_version(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def list_secret_versions(self,secret_name=None, marker=None, limit=None,**kwargs):   
+        try:
+            request = ListSecretVersionsRequest()
+            request.secret_name = secret_name
+            request.marker = marker
+            request.limit = limit
+            response = self._get_dew_client().cms_client.list_secret_versions(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+
+    def show_secret_version(self,secret_name=None,version_id=None,**kwargs):
+        try:
+            request = ShowSecretVersionRequest()
+            request.secret_name=secret_name
+            request.version_id = version_id
+            response = self._get_dew_client().cms_client.show_secret_version(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+    def update_version(self,secret_name=None, version_id=None, expire_time=None,**kwargs):
+        try:
+            request = UpdateVersionRequest()
+            request.version_id=version_id
+            request.secret_name=secret_name
+            request.body = UpdateVersionRequestBody(
+                expire_time=expire_time
+            )
+            response = self._get_dew_client().cms_client.update_version(request)
+            self.logger.info(response)
+        except exceptions.ClientRequestException as e:
+            self.logger.error("status_code= %s",e.status_code)
+            self.logger.error("request_id= %s",e.request_id)
+            self.logger.error("error_code= %s",e.error_code)
+            self.logger.error("error_msg= %s",e.error_msg)
+            
+
diff --git a/dew_client.py b/dew_client.py
new file mode 100644
index 0000000..8067916
--- /dev/null
+++ b/dew_client.py
@@ -0,0 +1,44 @@
+from huaweicloudsdkcore.auth.credentials import BasicCredentials
+from huaweicloudsdkcore.exceptions import exceptions
+from huaweicloudsdkkms.v2.region.kms_region import KmsRegion
+from huaweicloudsdkkms.v2 import *
+from huaweicloudsdkkps.v3.region.kps_region import KpsRegion
+from huaweicloudsdkkps.v3 import *
+from huaweicloudsdkcsms.v1.region.csms_region import CsmsRegion
+from huaweicloudsdkcsms.v1 import *
+from typing import Any, Coroutine, Dict, List, Optional, Union
+
+from prefect import get_run_logger, task
+from prefect.blocks.abstract import SecretBlock
+from prefect.utilities.asyncutils import run_sync_in_worker_thread, sync_compatible
+from pydantic import VERSION as PYDANTIC_VERSION
+import json
+if PYDANTIC_VERSION.startswith("2."):
+    from pydantic.v1 import Field
+else:
+    from pydantic import Field
+class DewClient():
+    def __init__(self,region_id:str,ak:str,sk:str):
+        self.region_id=region_id
+        self.__ak=ak
+        self.__sk=sk
+    @property
+    def kms_client(self)->KmsClient:
+        return KmsClient.new_builder() \
+            .with_credentials(BasicCredentials(self.__ak,self.__sk)) \
+            .with_region(KmsRegion.value_of(self.region_id)) \
+            .build()
+    @property
+    def kps_client(self)->KpsClient:        
+        return KpsClient.new_builder() \
+            .with_credentials(BasicCredentials(self.__ak,self.__sk)) \
+            .with_region(KpsRegion.value_of(self.region_id)) \
+            .build()
+    @property
+    def cms_client(self)->CsmsClient:    
+        return CsmsClient.new_builder() \
+            .with_credentials(BasicCredentials(self.__ak,self.__sk)) \
+            .with_region(CsmsRegion.value_of(self.region_id)) \
+            .build()
+    
+    
\ No newline at end of file
diff --git a/test_dew.py b/test_dew.py
new file mode 100644
index 0000000..c00ce0e
--- /dev/null
+++ b/test_dew.py
@@ -0,0 +1,42 @@
+from prefect_huaweicloud.dew_block import DewBlock
+from contextlib import redirect_stdout  
+import asyncio
+from prefect import flow,task,Task
+import pytest
+
+
+
+def test_list_keys(test_huaweicloud_dew_block):
+    test_huaweicloud_dew_block.list_keys()
+
+def kms_key_under_test(huaweicloud_dew_block,key_alias=None):
+     test_key=huaweicloud_dew_block.create_key(key_alias=key_alias)
+     return dict(
+          key_alias=key_alias,
+          key_id=test_key.key_info.key_id,
+          key_description=None,
+          pending_days=7
+     )
+
+@flow
+def test_key_lifecycle_management(kms_key_under_test,huaweicloud_dew_block):
+     row_key_alias=kms_key_under_test['key_alias']
+     huaweicloud_dew_block.create_key(**kms_key_under_test)
+     huaweicloud_dew_block.disable_key(**kms_key_under_test)
+     huaweicloud_dew_block.enable_key(**kms_key_under_test)
+     kms_key_under_test['key_alias']="test_alias"
+     huaweicloud_dew_block.update_key_Alias(**kms_key_under_test)
+     kms_key_under_test['key_alias']=row_key_alias
+     huaweicloud_dew_block.update_key_Alias(**kms_key_under_test)
+     kms_key_under_test['key_description']="test_update_description"
+     huaweicloud_dew_block.update_key_description(**kms_key_under_test)
+     huaweicloud_dew_block.delete_key(**kms_key_under_test)     
+     huaweicloud_dew_block.cancel_key_deletion(**kms_key_under_test)
+     huaweicloud_dew_block.enable_key(**kms_key_under_test)
+
+     
+
+
+if __name__=="__main__":
+    huaweicloud_dew_block = DewBlock.load("test-dew-block")
+    test_key_lifecycle_management(kms_key_under_test(huaweicloud_dew_block,key_alias="12-26"),huaweicloud_dew_block)
\ No newline at end of file
-- 
Gitee


From 328371a5589dc788031179ad69d08158dc0dda6e Mon Sep 17 00:00:00 2001
From: lky0312 <523175094@qq.com>
Date: Tue, 26 Dec 2023 14:49:55 +0800
Subject: [PATCH 4/4] Delete some useless code

---
 prefect_huaweicloud/dew_block.py | 40 ++------------------------------
 1 file changed, 2 insertions(+), 38 deletions(-)

diff --git a/prefect_huaweicloud/dew_block.py b/prefect_huaweicloud/dew_block.py
index d53488d..a7fa143 100644
--- a/prefect_huaweicloud/dew_block.py
+++ b/prefect_huaweicloud/dew_block.py
@@ -3,7 +3,7 @@ from typing import Any, Dict, List, Optional, Union
 from logging import Logger
 from pydantic import Field, SecretStr
 # from prefect import get_run_logger, task
-from prefect.blocks.abstract import SecretBlock
+from prefect.blocks.abstract import Block
 from prefect.utilities.asyncutils import run_sync_in_worker_thread, sync_compatible
 from prefect.logging.loggers import get_logger, get_run_logger
 from prefect.exceptions import MissingContextError
@@ -25,7 +25,7 @@ from huaweicloudsdkcsms.v1.region.csms_region import CsmsRegion
 from huaweicloudsdkcsms.v1 import *
 from huaweicloudsdkkms.v2 import *
 from huaweicloudsdkkps.v3 import *
-class DewBlock(SecretBlock):
+class DewBlock(Block):
 
     _logo_url = "https://res-static.hc-cdn.cn/cloudbu-site/public/header-icon/Storage/OBS.png"  # noqa
     _block_type_name = "HuaweiCloud DEW"
@@ -61,42 +61,6 @@ class DewBlock(SecretBlock):
             sk=self.huawei_cloud_secret_access_key.get_secret_value(),
             region_id=self.region_id,
             )
-
-
-    @sync_compatible
-    async def read_secret(self,key_id:str=None,cipher_text:str=None,**kwargs):
-        
-        response =await run_sync_in_worker_thread(self._get_dew_client().decrypt_data_key, key_id,cipher_text,32)
-        if hasattr(response, 'status_code') and response.status_code==200:
-            self.logger.info(f"|status_code:200| The secret {key_id!r} data was successfully read.")
-        return response
-
-    @sync_compatible
-    async def write_secret(self,key_id:str=None,plain_text:str=None,**kwargs):        
-        global encrypt_data_key_response
-        if key_id is None :
-            new_key = await run_sync_in_worker_thread(self._get_dew_client().create_key,key_alias="new_key",key_spec="AES_256")
-            new_data_key = await run_sync_in_worker_thread(self._get_dew_client().create_data_key,new_key.key_id)
-            encrypt_data_key_response = await run_sync_in_worker_thread(self._get_dew_client().encrypt_data_key, new_key.key_id, plain_text or new_data_key.plain_text,32)
-     
-        elif plain_text is  None:
-            new_data_key =await run_sync_in_worker_thread(self._get_dew_client().create_data_key, key_id)
-            encrypt_data_key_response =await run_sync_in_worker_thread(self._get_dew_client().encrypt_data_key, key_id, new_data_key.plain_text,32)
-
-        else:
-            encrypt_data_key_response =await run_sync_in_worker_thread(self._get_dew_client().encrypt_data_key,key_id,plain_text,32)
-
-        if hasattr(encrypt_data_key_response, 'status_code') and encrypt_data_key_response.status_code==200:
-            self.logger.info(f"|status_code:200| The secret {key_id!r} data was successfully write.")
-        return encrypt_data_key_response
-        
-    @sync_compatible
-    async def delete_secret(self, key_id,pending_days,**kwargs):
-        
-        response =await run_sync_in_worker_thread(self._get_dew_client().delete_key,key_id=key_id,pending_days=pending_days)
-        if hasattr(response, 'status_code') and response.status_code==200:
-            self.logger.info(f"The secret {key_id} was deleted successfully.")
-        return response
    
     @property
     def logger(self) -> Logger:
-- 
Gitee