[AutoPR keyvault/data-plane] fix typos

azure-keyvault/azure/keyvault/key_vault_client.py

@@ -9,7 +9,7 @@
 # regenerated.
 # --------------------------------------------------------------------------
 
-from msrest.service_client import ServiceClient
+from msrest.service_client import SDKClient
 from msrest import Serializer, Deserializer
 from msrestazure import AzureConfiguration
 from .version import VERSION
@@ -37,13 +37,13 @@ def __init__(
 
         super(KeyVaultClientConfiguration, self).__init__(base_url)
 
-        self.add_user_agent('azure-keyvault,/{}'.format(VERSION))
+        self.add_user_agent('azure-keyvault/{}'.format(VERSION))
         self.add_user_agent('Azure-SDK-For-Python')
 
         self.credentials = credentials
 
 
-class KeyVaultClient(object):
+class KeyVaultClient(SDKClient):
     """The key vault client performs cryptographic key operations and vault operations against the Key Vault service.
 
     :ivar config: Configuration for client.
@@ -58,7 +58,7 @@ def __init__(
             self, credentials):
 
         self.config = KeyVaultClientConfiguration(credentials)
-        self._client = ServiceClient(self.config.credentials, self.config)
+        super(KeyVaultClient, self).__init__(self.config.credentials, self.config)
 
         client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
         self.api_version = '7.0-preview'
@@ -85,7 +85,7 @@ def create_key(
          JsonWebKeyType. Possible values include: 'EC', 'EC-HSM', 'RSA',
          'RSA-HSM', 'oct'
         :type kty: str or ~azure.keyvault.models.JsonWebKeyType
-        :param key_size: The key size in bytes. For example, 1024 or 2048.
+        :param key_size: The key size in bits. For example, 1024 or 2048.
         :type key_size: int
         :param key_ops:
         :type key_ops: list[str or ~azure.keyvault.models.JsonWebKeyOperation]
@@ -3934,6 +3934,141 @@ def merge_certificate(
         return deserialized
     merge_certificate.metadata = {'url': '/certificates/{certificate-name}/pending/merge'}
 
+    def backup_certificate(
+            self, vault_base_url, certificate_name, custom_headers=None, raw=False, **operation_config):
+        """Backs up the specified certificate.
+
+        Requests that a backup of the specified certificate be downloaded to
+        the client. All versions of the certificate will be downloaded. This
+        operation requires the certificates/backup permission.
+
+        :param vault_base_url: The vault name, for example
+         https://myvault.vault.azure.net.
+        :type vault_base_url: str
+        :param certificate_name: The name of the certificate.
+        :type certificate_name: str
+        :param dict custom_headers: headers that will be added to the request
+        :param bool raw: returns the direct response alongside the
+         deserialized response
+        :param operation_config: :ref:`Operation configuration
+         overrides<msrest:optionsforoperations>`.
+        :return: BackupCertificateResult or ClientRawResponse if raw=true
+        :rtype: ~azure.keyvault.models.BackupCertificateResult or
+         ~msrest.pipeline.ClientRawResponse
+        :raises:
+         :class:`KeyVaultErrorException<azure.keyvault.models.KeyVaultErrorException>`
+        """
+        # Construct URL
+        url = self.backup_certificate.metadata['url']
+        path_format_arguments = {
+            'vaultBaseUrl': self._serialize.url("vault_base_url", vault_base_url, 'str', skip_quote=True),
+            'certificate-name': self._serialize.url("certificate_name", certificate_name, 'str')
+        }
+        url = self._client.format_url(url, **path_format_arguments)
+
+        # Construct parameters
+        query_parameters = {}
+        query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')
+
+        # Construct headers
+        header_parameters = {}
+        header_parameters['Content-Type'] = 'application/json; charset=utf-8'
+        if self.config.generate_client_request_id:
+            header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
+        if custom_headers:
+            header_parameters.update(custom_headers)
+        if self.config.accept_language is not None:
+            header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
+
+        # Construct and send request
+        request = self._client.post(url, query_parameters)
+        response = self._client.send(request, header_parameters, stream=False, **operation_config)
+
+        if response.status_code not in [200]:
+            raise models.KeyVaultErrorException(self._deserialize, response)
+
+        deserialized = None
+
+        if response.status_code == 200:
+            deserialized = self._deserialize('BackupCertificateResult', response)
+
+        if raw:
+            client_raw_response = ClientRawResponse(deserialized, response)
+            return client_raw_response
+
+        return deserialized
+    backup_certificate.metadata = {'url': '/certificates/{certificate-name}/backup'}
+
+    def restore_certificate(
+            self, vault_base_url, certificate_bundle_backup, custom_headers=None, raw=False, **operation_config):
+        """Restores a backed up certificate to a vault.
+
+        Restores a backed up certificate, and all its versions, to a vault.
+        This operation requires the certificates/restore permission.
+
+        :param vault_base_url: The vault name, for example
+         https://myvault.vault.azure.net.
+        :type vault_base_url: str
+        :param certificate_bundle_backup: The backup blob associated with a
+         certificate bundle.
+        :type certificate_bundle_backup: bytes
+        :param dict custom_headers: headers that will be added to the request
+        :param bool raw: returns the direct response alongside the
+         deserialized response
+        :param operation_config: :ref:`Operation configuration
+         overrides<msrest:optionsforoperations>`.
+        :return: CertificateBundle or ClientRawResponse if raw=true
+        :rtype: ~azure.keyvault.models.CertificateBundle or
+         ~msrest.pipeline.ClientRawResponse
+        :raises:
+         :class:`KeyVaultErrorException<azure.keyvault.models.KeyVaultErrorException>`
+        """
+        parameters = models.CertificateRestoreParameters(certificate_bundle_backup=certificate_bundle_backup)
+
+        # Construct URL
+        url = self.restore_certificate.metadata['url']
+        path_format_arguments = {
+            'vaultBaseUrl': self._serialize.url("vault_base_url", vault_base_url, 'str', skip_quote=True)
+        }
+        url = self._client.format_url(url, **path_format_arguments)
+
+        # Construct parameters
+        query_parameters = {}
+        query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')
+
+        # Construct headers
+        header_parameters = {}
+        header_parameters['Content-Type'] = 'application/json; charset=utf-8'
+        if self.config.generate_client_request_id:
+            header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
+        if custom_headers:
+            header_parameters.update(custom_headers)
+        if self.config.accept_language is not None:
+            header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
+
+        # Construct body
+        body_content = self._serialize.body(parameters, 'CertificateRestoreParameters')
+
+        # Construct and send request
+        request = self._client.post(url, query_parameters)
+        response = self._client.send(
+            request, header_parameters, body_content, stream=False, **operation_config)
+
+        if response.status_code not in [200]:
+            raise models.KeyVaultErrorException(self._deserialize, response)
+
+        deserialized = None
+
+        if response.status_code == 200:
+            deserialized = self._deserialize('CertificateBundle', response)
+
+        if raw:
+            client_raw_response = ClientRawResponse(deserialized, response)
+            return client_raw_response
+
+        return deserialized
+    restore_certificate.metadata = {'url': '/certificates/restore'}
+
     def get_deleted_certificates(
             self, vault_base_url, maxresults=None, include_pending=None, custom_headers=None, raw=False, **operation_config):
         """Lists the deleted certificates in the specified vault currently
@@ -4424,7 +4559,7 @@ def get_deleted_storage_account(
         return deserialized
     get_deleted_storage_account.metadata = {'url': '/deletedstorage/{storage-account-name}'}
 
-    def purge_deleted_storge_account(
+    def purge_deleted_storage_account(
             self, vault_base_url, storage_account_name, custom_headers=None, raw=False, **operation_config):
         """Permanently deletes the specified storage account.
 
@@ -4449,7 +4584,7 @@ def purge_deleted_storge_account(
          :class:`KeyVaultErrorException<azure.keyvault.models.KeyVaultErrorException>`
         """
         # Construct URL
-        url = self.purge_deleted_storge_account.metadata['url']
+        url = self.purge_deleted_storage_account.metadata['url']
         path_format_arguments = {
             'vaultBaseUrl': self._serialize.url("vault_base_url", vault_base_url, 'str', skip_quote=True),
             'storage-account-name': self._serialize.url("storage_account_name", storage_account_name, 'str', pattern=r'^[0-9a-zA-Z]+$')
@@ -4480,7 +4615,7 @@ def purge_deleted_storge_account(
         if raw:
             client_raw_response = ClientRawResponse(None, response)
             return client_raw_response
-    purge_deleted_storge_account.metadata = {'url': '/deletedstorage/{storage-account-name}'}
+    purge_deleted_storage_account.metadata = {'url': '/deletedstorage/{storage-account-name}'}
 
     def recover_deleted_storage_account(
             self, vault_base_url, storage_account_name, custom_headers=None, raw=False, **operation_config):