diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v2016_10_01/_configuration.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v2016_10_01/_configuration.py index 28cf75e3d2b4..68d6f5b6bd2c 100644 --- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v2016_10_01/_configuration.py +++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v2016_10_01/_configuration.py @@ -8,7 +8,7 @@ # Changes may cause incorrect behavior and will be lost if the code is # regenerated. # -------------------------------------------------------------------------- -from azure.core.configuration import Configuration, ConnectionConfiguration +from azure.core.configuration import Configuration from azure.core.pipeline import policies from .version import VERSION @@ -38,11 +38,10 @@ def __init__(self, credentials, **kwargs): self.credentials = credentials def _configure(self, **kwargs): - self.connection = ConnectionConfiguration(**kwargs) - self.user_agent_policy = policies.UserAgentPolicy(**kwargs) - self.headers_policy = policies.HeadersPolicy(**kwargs) - self.proxy_policy = policies.ProxyPolicy(**kwargs) - self.logging_policy = policies.NetworkTraceLoggingPolicy(**kwargs) - self.retry_policy = policies.RetryPolicy(**kwargs) - self.custom_hook_policy = policies.CustomHookPolicy(**kwargs) - self.redirect_policy = policies.RedirectPolicy(**kwargs) + self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs) + self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs) + self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs) + self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get('retry_policy') or policies.RetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get('redirect_policy') or policies.RedirectPolicy(**kwargs) diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v2016_10_01/aio/_configuration_async.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v2016_10_01/aio/_configuration_async.py index a61d9eeff444..fb961bb4bd2d 100644 --- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v2016_10_01/aio/_configuration_async.py +++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v2016_10_01/aio/_configuration_async.py @@ -8,7 +8,7 @@ # Changes may cause incorrect behavior and will be lost if the code is # regenerated. # -------------------------------------------------------------------------- -from azure.core.configuration import Configuration, ConnectionConfiguration +from azure.core.configuration import Configuration from azure.core.pipeline import policies from ..version import VERSION @@ -38,10 +38,10 @@ def __init__(self, credentials, **kwargs): self.credentials = credentials def _configure(self, **kwargs): - self.connection = ConnectionConfiguration(**kwargs) - self.user_agent_policy = policies.UserAgentPolicy(**kwargs) - self.headers_policy = policies.HeadersPolicy(**kwargs) - self.proxy_policy = policies.ProxyPolicy(**kwargs) - self.logging_policy = policies.NetworkTraceLoggingPolicy(**kwargs) - self.retry_policy = policies.AsyncRetryPolicy(**kwargs) - self.redirect_policy = policies.AsyncRedirectPolicy(**kwargs) + self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs) + self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs) + self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs) + self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs) diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v2016_10_01/aio/operations_async/_key_vault_client_operations_async.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v2016_10_01/aio/operations_async/_key_vault_client_operations_async.py index b5cc965119ed..2e34320ea0fe 100644 --- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v2016_10_01/aio/operations_async/_key_vault_client_operations_async.py +++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v2016_10_01/aio/operations_async/_key_vault_client_operations_async.py @@ -394,6 +394,7 @@ def get_key_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -431,10 +432,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -469,6 +469,7 @@ def get_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -505,10 +506,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1152,6 +1152,7 @@ def get_deleted_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1188,10 +1189,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1659,6 +1659,7 @@ def get_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1695,10 +1696,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1732,6 +1732,7 @@ def get_secret_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1769,10 +1770,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1804,6 +1804,7 @@ def get_deleted_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1840,10 +1841,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2160,6 +2160,7 @@ def get_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2196,10 +2197,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2457,6 +2457,7 @@ def get_certificate_issuers( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2493,10 +2494,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2946,6 +2946,7 @@ def get_certificate_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2983,10 +2984,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3532,6 +3532,7 @@ def get_deleted_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3568,10 +3569,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3770,6 +3770,7 @@ def get_storage_accounts( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3806,10 +3807,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -4162,6 +4162,7 @@ def get_sas_definitions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4199,10 +4200,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v2016_10_01/operations/_key_vault_client_operations.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v2016_10_01/operations/_key_vault_client_operations.py index 0ae7fd5fb025..a84f1ad1ee7d 100644 --- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v2016_10_01/operations/_key_vault_client_operations.py +++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v2016_10_01/operations/_key_vault_client_operations.py @@ -394,6 +394,7 @@ def get_key_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -431,10 +432,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -469,6 +469,7 @@ def get_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -505,10 +506,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1152,6 +1152,7 @@ def get_deleted_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1188,10 +1189,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1659,6 +1659,7 @@ def get_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1695,10 +1696,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1732,6 +1732,7 @@ def get_secret_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1769,10 +1770,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1804,6 +1804,7 @@ def get_deleted_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1840,10 +1841,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2160,6 +2160,7 @@ def get_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2196,10 +2197,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2457,6 +2457,7 @@ def get_certificate_issuers( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2493,10 +2494,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2946,6 +2946,7 @@ def get_certificate_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2983,10 +2984,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3532,6 +3532,7 @@ def get_deleted_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3568,10 +3569,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3770,6 +3770,7 @@ def get_storage_accounts( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3806,10 +3807,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -4162,6 +4162,7 @@ def get_sas_definitions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4199,10 +4200,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v7_0/_configuration.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v7_0/_configuration.py index 28cf75e3d2b4..68d6f5b6bd2c 100644 --- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v7_0/_configuration.py +++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v7_0/_configuration.py @@ -8,7 +8,7 @@ # Changes may cause incorrect behavior and will be lost if the code is # regenerated. # -------------------------------------------------------------------------- -from azure.core.configuration import Configuration, ConnectionConfiguration +from azure.core.configuration import Configuration from azure.core.pipeline import policies from .version import VERSION @@ -38,11 +38,10 @@ def __init__(self, credentials, **kwargs): self.credentials = credentials def _configure(self, **kwargs): - self.connection = ConnectionConfiguration(**kwargs) - self.user_agent_policy = policies.UserAgentPolicy(**kwargs) - self.headers_policy = policies.HeadersPolicy(**kwargs) - self.proxy_policy = policies.ProxyPolicy(**kwargs) - self.logging_policy = policies.NetworkTraceLoggingPolicy(**kwargs) - self.retry_policy = policies.RetryPolicy(**kwargs) - self.custom_hook_policy = policies.CustomHookPolicy(**kwargs) - self.redirect_policy = policies.RedirectPolicy(**kwargs) + self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs) + self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs) + self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs) + self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get('retry_policy') or policies.RetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get('redirect_policy') or policies.RedirectPolicy(**kwargs) diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v7_0/aio/_configuration_async.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v7_0/aio/_configuration_async.py index a61d9eeff444..fb961bb4bd2d 100644 --- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v7_0/aio/_configuration_async.py +++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v7_0/aio/_configuration_async.py @@ -8,7 +8,7 @@ # Changes may cause incorrect behavior and will be lost if the code is # regenerated. # -------------------------------------------------------------------------- -from azure.core.configuration import Configuration, ConnectionConfiguration +from azure.core.configuration import Configuration from azure.core.pipeline import policies from ..version import VERSION @@ -38,10 +38,10 @@ def __init__(self, credentials, **kwargs): self.credentials = credentials def _configure(self, **kwargs): - self.connection = ConnectionConfiguration(**kwargs) - self.user_agent_policy = policies.UserAgentPolicy(**kwargs) - self.headers_policy = policies.HeadersPolicy(**kwargs) - self.proxy_policy = policies.ProxyPolicy(**kwargs) - self.logging_policy = policies.NetworkTraceLoggingPolicy(**kwargs) - self.retry_policy = policies.AsyncRetryPolicy(**kwargs) - self.redirect_policy = policies.AsyncRedirectPolicy(**kwargs) + self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs) + self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs) + self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs) + self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs) diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v7_0/aio/operations_async/_key_vault_client_operations_async.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v7_0/aio/operations_async/_key_vault_client_operations_async.py index 08e45c2b44a7..1675be60f93a 100644 --- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v7_0/aio/operations_async/_key_vault_client_operations_async.py +++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v7_0/aio/operations_async/_key_vault_client_operations_async.py @@ -393,6 +393,7 @@ def get_key_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -430,10 +431,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -468,6 +468,7 @@ def get_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -504,10 +505,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1151,6 +1151,7 @@ def get_deleted_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1187,10 +1188,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1656,6 +1656,7 @@ def get_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1692,10 +1693,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1729,6 +1729,7 @@ def get_secret_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1766,10 +1767,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1801,6 +1801,7 @@ def get_deleted_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1837,10 +1838,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2160,6 +2160,7 @@ def get_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2198,10 +2199,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2459,6 +2459,7 @@ def get_certificate_issuers( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2495,10 +2496,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2946,6 +2946,7 @@ def get_certificate_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2983,10 +2984,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3654,6 +3654,7 @@ def get_deleted_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3692,10 +3693,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3894,6 +3894,7 @@ def get_storage_accounts( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3930,10 +3931,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3965,6 +3965,7 @@ def get_deleted_storage_accounts( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4001,10 +4002,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -4641,6 +4641,7 @@ def get_sas_definitions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4678,10 +4679,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -4716,6 +4716,7 @@ def get_deleted_sas_definitions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4753,10 +4754,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v7_0/operations/_key_vault_client_operations.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v7_0/operations/_key_vault_client_operations.py index b9ed6e10ea21..da216d1db657 100644 --- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v7_0/operations/_key_vault_client_operations.py +++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/_generated/v7_0/operations/_key_vault_client_operations.py @@ -393,6 +393,7 @@ def get_key_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -430,10 +431,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -468,6 +468,7 @@ def get_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -504,10 +505,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1151,6 +1151,7 @@ def get_deleted_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1187,10 +1188,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1656,6 +1656,7 @@ def get_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1692,10 +1693,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1729,6 +1729,7 @@ def get_secret_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1766,10 +1767,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1801,6 +1801,7 @@ def get_deleted_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1837,10 +1838,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2160,6 +2160,7 @@ def get_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2198,10 +2199,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2459,6 +2459,7 @@ def get_certificate_issuers( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2495,10 +2496,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2946,6 +2946,7 @@ def get_certificate_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2983,10 +2984,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3654,6 +3654,7 @@ def get_deleted_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3692,10 +3693,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3894,6 +3894,7 @@ def get_storage_accounts( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3930,10 +3931,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3965,6 +3965,7 @@ def get_deleted_storage_accounts( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4001,10 +4002,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -4641,6 +4641,7 @@ def get_sas_definitions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4678,10 +4679,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -4716,6 +4716,7 @@ def get_deleted_sas_definitions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4753,10 +4754,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) diff --git a/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_client.py b/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_client.py index df9e0344271f..2eab11fa5e8f 100644 --- a/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_client.py +++ b/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_client.py @@ -252,7 +252,7 @@ def list_deleted_keys(self, **kwargs): :caption: List all the deleted keys :dedent: 8 """ - max_page_size = kwargs.get("max_page_size", None) + max_page_size = kwargs.pop("max_page_size", None) return self._client.get_deleted_keys( self._vault_endpoint, maxresults=max_page_size, @@ -276,7 +276,7 @@ def list_properties_of_keys(self, **kwargs): :caption: List all keys :dedent: 8 """ - max_page_size = kwargs.get("max_page_size", None) + max_page_size = kwargs.pop("max_page_size", None) return self._client.get_keys( self._vault_endpoint, maxresults=max_page_size, @@ -301,7 +301,7 @@ def list_key_versions(self, name, **kwargs): :caption: List all versions of a key :dedent: 8 """ - max_page_size = kwargs.get("max_page_size", None) + max_page_size = kwargs.pop("max_page_size", None) return self._client.get_key_versions( self._vault_endpoint, name, diff --git a/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v2016_10_01/_configuration.py b/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v2016_10_01/_configuration.py index 28cf75e3d2b4..68d6f5b6bd2c 100644 --- a/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v2016_10_01/_configuration.py +++ b/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v2016_10_01/_configuration.py @@ -8,7 +8,7 @@ # Changes may cause incorrect behavior and will be lost if the code is # regenerated. # -------------------------------------------------------------------------- -from azure.core.configuration import Configuration, ConnectionConfiguration +from azure.core.configuration import Configuration from azure.core.pipeline import policies from .version import VERSION @@ -38,11 +38,10 @@ def __init__(self, credentials, **kwargs): self.credentials = credentials def _configure(self, **kwargs): - self.connection = ConnectionConfiguration(**kwargs) - self.user_agent_policy = policies.UserAgentPolicy(**kwargs) - self.headers_policy = policies.HeadersPolicy(**kwargs) - self.proxy_policy = policies.ProxyPolicy(**kwargs) - self.logging_policy = policies.NetworkTraceLoggingPolicy(**kwargs) - self.retry_policy = policies.RetryPolicy(**kwargs) - self.custom_hook_policy = policies.CustomHookPolicy(**kwargs) - self.redirect_policy = policies.RedirectPolicy(**kwargs) + self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs) + self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs) + self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs) + self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get('retry_policy') or policies.RetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get('redirect_policy') or policies.RedirectPolicy(**kwargs) diff --git a/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v2016_10_01/aio/_configuration_async.py b/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v2016_10_01/aio/_configuration_async.py index a61d9eeff444..fb961bb4bd2d 100644 --- a/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v2016_10_01/aio/_configuration_async.py +++ b/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v2016_10_01/aio/_configuration_async.py @@ -8,7 +8,7 @@ # Changes may cause incorrect behavior and will be lost if the code is # regenerated. # -------------------------------------------------------------------------- -from azure.core.configuration import Configuration, ConnectionConfiguration +from azure.core.configuration import Configuration from azure.core.pipeline import policies from ..version import VERSION @@ -38,10 +38,10 @@ def __init__(self, credentials, **kwargs): self.credentials = credentials def _configure(self, **kwargs): - self.connection = ConnectionConfiguration(**kwargs) - self.user_agent_policy = policies.UserAgentPolicy(**kwargs) - self.headers_policy = policies.HeadersPolicy(**kwargs) - self.proxy_policy = policies.ProxyPolicy(**kwargs) - self.logging_policy = policies.NetworkTraceLoggingPolicy(**kwargs) - self.retry_policy = policies.AsyncRetryPolicy(**kwargs) - self.redirect_policy = policies.AsyncRedirectPolicy(**kwargs) + self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs) + self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs) + self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs) + self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs) diff --git a/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v2016_10_01/aio/operations_async/_key_vault_client_operations_async.py b/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v2016_10_01/aio/operations_async/_key_vault_client_operations_async.py index b5cc965119ed..2e34320ea0fe 100644 --- a/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v2016_10_01/aio/operations_async/_key_vault_client_operations_async.py +++ b/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v2016_10_01/aio/operations_async/_key_vault_client_operations_async.py @@ -394,6 +394,7 @@ def get_key_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -431,10 +432,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -469,6 +469,7 @@ def get_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -505,10 +506,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1152,6 +1152,7 @@ def get_deleted_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1188,10 +1189,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1659,6 +1659,7 @@ def get_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1695,10 +1696,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1732,6 +1732,7 @@ def get_secret_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1769,10 +1770,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1804,6 +1804,7 @@ def get_deleted_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1840,10 +1841,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2160,6 +2160,7 @@ def get_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2196,10 +2197,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2457,6 +2457,7 @@ def get_certificate_issuers( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2493,10 +2494,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2946,6 +2946,7 @@ def get_certificate_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2983,10 +2984,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3532,6 +3532,7 @@ def get_deleted_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3568,10 +3569,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3770,6 +3770,7 @@ def get_storage_accounts( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3806,10 +3807,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -4162,6 +4162,7 @@ def get_sas_definitions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4199,10 +4200,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) diff --git a/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v2016_10_01/operations/_key_vault_client_operations.py b/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v2016_10_01/operations/_key_vault_client_operations.py index 0ae7fd5fb025..a84f1ad1ee7d 100644 --- a/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v2016_10_01/operations/_key_vault_client_operations.py +++ b/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v2016_10_01/operations/_key_vault_client_operations.py @@ -394,6 +394,7 @@ def get_key_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -431,10 +432,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -469,6 +469,7 @@ def get_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -505,10 +506,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1152,6 +1152,7 @@ def get_deleted_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1188,10 +1189,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1659,6 +1659,7 @@ def get_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1695,10 +1696,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1732,6 +1732,7 @@ def get_secret_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1769,10 +1770,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1804,6 +1804,7 @@ def get_deleted_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1840,10 +1841,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2160,6 +2160,7 @@ def get_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2196,10 +2197,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2457,6 +2457,7 @@ def get_certificate_issuers( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2493,10 +2494,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2946,6 +2946,7 @@ def get_certificate_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2983,10 +2984,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3532,6 +3532,7 @@ def get_deleted_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3568,10 +3569,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3770,6 +3770,7 @@ def get_storage_accounts( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3806,10 +3807,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -4162,6 +4162,7 @@ def get_sas_definitions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4199,10 +4200,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) diff --git a/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v7_0/_configuration.py b/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v7_0/_configuration.py index 28cf75e3d2b4..68d6f5b6bd2c 100644 --- a/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v7_0/_configuration.py +++ b/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v7_0/_configuration.py @@ -8,7 +8,7 @@ # Changes may cause incorrect behavior and will be lost if the code is # regenerated. # -------------------------------------------------------------------------- -from azure.core.configuration import Configuration, ConnectionConfiguration +from azure.core.configuration import Configuration from azure.core.pipeline import policies from .version import VERSION @@ -38,11 +38,10 @@ def __init__(self, credentials, **kwargs): self.credentials = credentials def _configure(self, **kwargs): - self.connection = ConnectionConfiguration(**kwargs) - self.user_agent_policy = policies.UserAgentPolicy(**kwargs) - self.headers_policy = policies.HeadersPolicy(**kwargs) - self.proxy_policy = policies.ProxyPolicy(**kwargs) - self.logging_policy = policies.NetworkTraceLoggingPolicy(**kwargs) - self.retry_policy = policies.RetryPolicy(**kwargs) - self.custom_hook_policy = policies.CustomHookPolicy(**kwargs) - self.redirect_policy = policies.RedirectPolicy(**kwargs) + self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs) + self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs) + self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs) + self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get('retry_policy') or policies.RetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get('redirect_policy') or policies.RedirectPolicy(**kwargs) diff --git a/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v7_0/aio/_configuration_async.py b/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v7_0/aio/_configuration_async.py index a61d9eeff444..fb961bb4bd2d 100644 --- a/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v7_0/aio/_configuration_async.py +++ b/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v7_0/aio/_configuration_async.py @@ -8,7 +8,7 @@ # Changes may cause incorrect behavior and will be lost if the code is # regenerated. # -------------------------------------------------------------------------- -from azure.core.configuration import Configuration, ConnectionConfiguration +from azure.core.configuration import Configuration from azure.core.pipeline import policies from ..version import VERSION @@ -38,10 +38,10 @@ def __init__(self, credentials, **kwargs): self.credentials = credentials def _configure(self, **kwargs): - self.connection = ConnectionConfiguration(**kwargs) - self.user_agent_policy = policies.UserAgentPolicy(**kwargs) - self.headers_policy = policies.HeadersPolicy(**kwargs) - self.proxy_policy = policies.ProxyPolicy(**kwargs) - self.logging_policy = policies.NetworkTraceLoggingPolicy(**kwargs) - self.retry_policy = policies.AsyncRetryPolicy(**kwargs) - self.redirect_policy = policies.AsyncRedirectPolicy(**kwargs) + self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs) + self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs) + self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs) + self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs) diff --git a/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v7_0/aio/operations_async/_key_vault_client_operations_async.py b/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v7_0/aio/operations_async/_key_vault_client_operations_async.py index 08e45c2b44a7..1675be60f93a 100644 --- a/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v7_0/aio/operations_async/_key_vault_client_operations_async.py +++ b/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v7_0/aio/operations_async/_key_vault_client_operations_async.py @@ -393,6 +393,7 @@ def get_key_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -430,10 +431,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -468,6 +468,7 @@ def get_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -504,10 +505,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1151,6 +1151,7 @@ def get_deleted_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1187,10 +1188,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1656,6 +1656,7 @@ def get_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1692,10 +1693,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1729,6 +1729,7 @@ def get_secret_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1766,10 +1767,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1801,6 +1801,7 @@ def get_deleted_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1837,10 +1838,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2160,6 +2160,7 @@ def get_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2198,10 +2199,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2459,6 +2459,7 @@ def get_certificate_issuers( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2495,10 +2496,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2946,6 +2946,7 @@ def get_certificate_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2983,10 +2984,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3654,6 +3654,7 @@ def get_deleted_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3692,10 +3693,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3894,6 +3894,7 @@ def get_storage_accounts( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3930,10 +3931,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3965,6 +3965,7 @@ def get_deleted_storage_accounts( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4001,10 +4002,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -4641,6 +4641,7 @@ def get_sas_definitions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4678,10 +4679,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -4716,6 +4716,7 @@ def get_deleted_sas_definitions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4753,10 +4754,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) diff --git a/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v7_0/operations/_key_vault_client_operations.py b/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v7_0/operations/_key_vault_client_operations.py index b9ed6e10ea21..da216d1db657 100644 --- a/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v7_0/operations/_key_vault_client_operations.py +++ b/sdk/keyvault/azure-keyvault-keys/azure/keyvault/keys/_shared/_generated/v7_0/operations/_key_vault_client_operations.py @@ -393,6 +393,7 @@ def get_key_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -430,10 +431,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -468,6 +468,7 @@ def get_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -504,10 +505,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1151,6 +1151,7 @@ def get_deleted_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1187,10 +1188,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1656,6 +1656,7 @@ def get_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1692,10 +1693,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1729,6 +1729,7 @@ def get_secret_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1766,10 +1767,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1801,6 +1801,7 @@ def get_deleted_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1837,10 +1838,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2160,6 +2160,7 @@ def get_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2198,10 +2199,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2459,6 +2459,7 @@ def get_certificate_issuers( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2495,10 +2496,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2946,6 +2946,7 @@ def get_certificate_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2983,10 +2984,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3654,6 +3654,7 @@ def get_deleted_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3692,10 +3693,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3894,6 +3894,7 @@ def get_storage_accounts( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3930,10 +3931,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3965,6 +3965,7 @@ def get_deleted_storage_accounts( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4001,10 +4002,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -4641,6 +4641,7 @@ def get_sas_definitions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4678,10 +4679,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -4716,6 +4716,7 @@ def get_deleted_sas_definitions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4753,10 +4754,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) diff --git a/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_client.py b/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_client.py index eaa53f3490fc..2168e0ecaab2 100644 --- a/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_client.py +++ b/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_client.py @@ -180,7 +180,7 @@ def list_properties_of_secrets(self, **kwargs): :dedent: 8 """ - max_page_size = kwargs.get("max_page_size", None) + max_page_size = kwargs.pop("max_page_size", None) return self._client.get_secrets( self._vault_endpoint, maxresults=max_page_size, @@ -207,7 +207,7 @@ def list_secret_versions(self, name, **kwargs): :dedent: 8 """ - max_page_size = kwargs.get("max_page_size", None) + max_page_size = kwargs.pop("max_page_size", None) return self._client.get_secret_versions( self._vault_endpoint, name, @@ -329,7 +329,7 @@ def list_deleted_secrets(self, **kwargs): :dedent: 8 """ - max_page_size = kwargs.get("max_page_size", None) + max_page_size = kwargs.pop("max_page_size", None) return self._client.get_deleted_secrets( self._vault_endpoint, maxresults=max_page_size, diff --git a/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v2016_10_01/_configuration.py b/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v2016_10_01/_configuration.py index 28cf75e3d2b4..68d6f5b6bd2c 100644 --- a/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v2016_10_01/_configuration.py +++ b/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v2016_10_01/_configuration.py @@ -8,7 +8,7 @@ # Changes may cause incorrect behavior and will be lost if the code is # regenerated. # -------------------------------------------------------------------------- -from azure.core.configuration import Configuration, ConnectionConfiguration +from azure.core.configuration import Configuration from azure.core.pipeline import policies from .version import VERSION @@ -38,11 +38,10 @@ def __init__(self, credentials, **kwargs): self.credentials = credentials def _configure(self, **kwargs): - self.connection = ConnectionConfiguration(**kwargs) - self.user_agent_policy = policies.UserAgentPolicy(**kwargs) - self.headers_policy = policies.HeadersPolicy(**kwargs) - self.proxy_policy = policies.ProxyPolicy(**kwargs) - self.logging_policy = policies.NetworkTraceLoggingPolicy(**kwargs) - self.retry_policy = policies.RetryPolicy(**kwargs) - self.custom_hook_policy = policies.CustomHookPolicy(**kwargs) - self.redirect_policy = policies.RedirectPolicy(**kwargs) + self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs) + self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs) + self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs) + self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get('retry_policy') or policies.RetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get('redirect_policy') or policies.RedirectPolicy(**kwargs) diff --git a/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v2016_10_01/aio/_configuration_async.py b/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v2016_10_01/aio/_configuration_async.py index a61d9eeff444..fb961bb4bd2d 100644 --- a/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v2016_10_01/aio/_configuration_async.py +++ b/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v2016_10_01/aio/_configuration_async.py @@ -8,7 +8,7 @@ # Changes may cause incorrect behavior and will be lost if the code is # regenerated. # -------------------------------------------------------------------------- -from azure.core.configuration import Configuration, ConnectionConfiguration +from azure.core.configuration import Configuration from azure.core.pipeline import policies from ..version import VERSION @@ -38,10 +38,10 @@ def __init__(self, credentials, **kwargs): self.credentials = credentials def _configure(self, **kwargs): - self.connection = ConnectionConfiguration(**kwargs) - self.user_agent_policy = policies.UserAgentPolicy(**kwargs) - self.headers_policy = policies.HeadersPolicy(**kwargs) - self.proxy_policy = policies.ProxyPolicy(**kwargs) - self.logging_policy = policies.NetworkTraceLoggingPolicy(**kwargs) - self.retry_policy = policies.AsyncRetryPolicy(**kwargs) - self.redirect_policy = policies.AsyncRedirectPolicy(**kwargs) + self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs) + self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs) + self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs) + self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs) diff --git a/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v2016_10_01/aio/operations_async/_key_vault_client_operations_async.py b/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v2016_10_01/aio/operations_async/_key_vault_client_operations_async.py index b5cc965119ed..2e34320ea0fe 100644 --- a/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v2016_10_01/aio/operations_async/_key_vault_client_operations_async.py +++ b/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v2016_10_01/aio/operations_async/_key_vault_client_operations_async.py @@ -394,6 +394,7 @@ def get_key_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -431,10 +432,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -469,6 +469,7 @@ def get_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -505,10 +506,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1152,6 +1152,7 @@ def get_deleted_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1188,10 +1189,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1659,6 +1659,7 @@ def get_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1695,10 +1696,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1732,6 +1732,7 @@ def get_secret_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1769,10 +1770,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1804,6 +1804,7 @@ def get_deleted_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1840,10 +1841,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2160,6 +2160,7 @@ def get_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2196,10 +2197,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2457,6 +2457,7 @@ def get_certificate_issuers( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2493,10 +2494,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2946,6 +2946,7 @@ def get_certificate_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2983,10 +2984,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3532,6 +3532,7 @@ def get_deleted_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3568,10 +3569,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3770,6 +3770,7 @@ def get_storage_accounts( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3806,10 +3807,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -4162,6 +4162,7 @@ def get_sas_definitions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4199,10 +4200,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) diff --git a/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v2016_10_01/operations/_key_vault_client_operations.py b/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v2016_10_01/operations/_key_vault_client_operations.py index 0ae7fd5fb025..a84f1ad1ee7d 100644 --- a/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v2016_10_01/operations/_key_vault_client_operations.py +++ b/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v2016_10_01/operations/_key_vault_client_operations.py @@ -394,6 +394,7 @@ def get_key_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -431,10 +432,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -469,6 +469,7 @@ def get_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -505,10 +506,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1152,6 +1152,7 @@ def get_deleted_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1188,10 +1189,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1659,6 +1659,7 @@ def get_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1695,10 +1696,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1732,6 +1732,7 @@ def get_secret_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1769,10 +1770,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1804,6 +1804,7 @@ def get_deleted_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1840,10 +1841,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2160,6 +2160,7 @@ def get_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2196,10 +2197,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2457,6 +2457,7 @@ def get_certificate_issuers( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2493,10 +2494,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2946,6 +2946,7 @@ def get_certificate_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2983,10 +2984,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3532,6 +3532,7 @@ def get_deleted_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3568,10 +3569,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3770,6 +3770,7 @@ def get_storage_accounts( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3806,10 +3807,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -4162,6 +4162,7 @@ def get_sas_definitions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4199,10 +4200,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) diff --git a/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v7_0/_configuration.py b/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v7_0/_configuration.py index 28cf75e3d2b4..68d6f5b6bd2c 100644 --- a/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v7_0/_configuration.py +++ b/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v7_0/_configuration.py @@ -8,7 +8,7 @@ # Changes may cause incorrect behavior and will be lost if the code is # regenerated. # -------------------------------------------------------------------------- -from azure.core.configuration import Configuration, ConnectionConfiguration +from azure.core.configuration import Configuration from azure.core.pipeline import policies from .version import VERSION @@ -38,11 +38,10 @@ def __init__(self, credentials, **kwargs): self.credentials = credentials def _configure(self, **kwargs): - self.connection = ConnectionConfiguration(**kwargs) - self.user_agent_policy = policies.UserAgentPolicy(**kwargs) - self.headers_policy = policies.HeadersPolicy(**kwargs) - self.proxy_policy = policies.ProxyPolicy(**kwargs) - self.logging_policy = policies.NetworkTraceLoggingPolicy(**kwargs) - self.retry_policy = policies.RetryPolicy(**kwargs) - self.custom_hook_policy = policies.CustomHookPolicy(**kwargs) - self.redirect_policy = policies.RedirectPolicy(**kwargs) + self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs) + self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs) + self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs) + self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get('retry_policy') or policies.RetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get('redirect_policy') or policies.RedirectPolicy(**kwargs) diff --git a/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v7_0/aio/_configuration_async.py b/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v7_0/aio/_configuration_async.py index a61d9eeff444..fb961bb4bd2d 100644 --- a/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v7_0/aio/_configuration_async.py +++ b/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v7_0/aio/_configuration_async.py @@ -8,7 +8,7 @@ # Changes may cause incorrect behavior and will be lost if the code is # regenerated. # -------------------------------------------------------------------------- -from azure.core.configuration import Configuration, ConnectionConfiguration +from azure.core.configuration import Configuration from azure.core.pipeline import policies from ..version import VERSION @@ -38,10 +38,10 @@ def __init__(self, credentials, **kwargs): self.credentials = credentials def _configure(self, **kwargs): - self.connection = ConnectionConfiguration(**kwargs) - self.user_agent_policy = policies.UserAgentPolicy(**kwargs) - self.headers_policy = policies.HeadersPolicy(**kwargs) - self.proxy_policy = policies.ProxyPolicy(**kwargs) - self.logging_policy = policies.NetworkTraceLoggingPolicy(**kwargs) - self.retry_policy = policies.AsyncRetryPolicy(**kwargs) - self.redirect_policy = policies.AsyncRedirectPolicy(**kwargs) + self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs) + self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs) + self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs) + self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs) diff --git a/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v7_0/aio/operations_async/_key_vault_client_operations_async.py b/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v7_0/aio/operations_async/_key_vault_client_operations_async.py index 08e45c2b44a7..1675be60f93a 100644 --- a/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v7_0/aio/operations_async/_key_vault_client_operations_async.py +++ b/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v7_0/aio/operations_async/_key_vault_client_operations_async.py @@ -393,6 +393,7 @@ def get_key_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -430,10 +431,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -468,6 +468,7 @@ def get_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -504,10 +505,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1151,6 +1151,7 @@ def get_deleted_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1187,10 +1188,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1656,6 +1656,7 @@ def get_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1692,10 +1693,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1729,6 +1729,7 @@ def get_secret_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1766,10 +1767,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1801,6 +1801,7 @@ def get_deleted_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1837,10 +1838,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2160,6 +2160,7 @@ def get_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2198,10 +2199,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2459,6 +2459,7 @@ def get_certificate_issuers( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2495,10 +2496,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2946,6 +2946,7 @@ def get_certificate_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2983,10 +2984,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3654,6 +3654,7 @@ def get_deleted_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3692,10 +3693,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3894,6 +3894,7 @@ def get_storage_accounts( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3930,10 +3931,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3965,6 +3965,7 @@ def get_deleted_storage_accounts( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4001,10 +4002,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -4641,6 +4641,7 @@ def get_sas_definitions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4678,10 +4679,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -4716,6 +4716,7 @@ def get_deleted_sas_definitions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4753,10 +4754,9 @@ async def extract_data_async(response): async def get_next_async(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request) + pipeline_response = await self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) diff --git a/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v7_0/operations/_key_vault_client_operations.py b/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v7_0/operations/_key_vault_client_operations.py index b9ed6e10ea21..da216d1db657 100644 --- a/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v7_0/operations/_key_vault_client_operations.py +++ b/sdk/keyvault/azure-keyvault-secrets/azure/keyvault/secrets/_shared/_generated/v7_0/operations/_key_vault_client_operations.py @@ -393,6 +393,7 @@ def get_key_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -430,10 +431,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -468,6 +468,7 @@ def get_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -504,10 +505,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1151,6 +1151,7 @@ def get_deleted_keys( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1187,10 +1188,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1656,6 +1656,7 @@ def get_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1692,10 +1693,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1729,6 +1729,7 @@ def get_secret_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1766,10 +1767,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -1801,6 +1801,7 @@ def get_deleted_secrets( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -1837,10 +1838,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2160,6 +2160,7 @@ def get_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2198,10 +2199,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2459,6 +2459,7 @@ def get_certificate_issuers( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2495,10 +2496,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -2946,6 +2946,7 @@ def get_certificate_versions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -2983,10 +2984,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3654,6 +3654,7 @@ def get_deleted_certificates( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3692,10 +3693,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3894,6 +3894,7 @@ def get_storage_accounts( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -3930,10 +3931,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -3965,6 +3965,7 @@ def get_deleted_storage_accounts( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4001,10 +4002,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -4641,6 +4641,7 @@ def get_sas_definitions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4678,10 +4679,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize) @@ -4716,6 +4716,7 @@ def get_deleted_sas_definitions( :raises: :class:`KeyVaultErrorException` """ + error_map = kwargs.pop('error_map', None) def prepare_request(next_link=None): query_parameters = {} if not next_link: @@ -4753,10 +4754,9 @@ def extract_data(response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request) + pipeline_response = self._client._pipeline.run(request, **kwargs) response = pipeline_response.http_response - error_map = kwargs.pop('error_map', None) if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise models.KeyVaultErrorException(response, self._deserialize)