diff --git a/sdk/keyvault/azure-mgmt-keyvault/_meta.json b/sdk/keyvault/azure-mgmt-keyvault/_meta.json index 5626ca9b8bd7..0b7480d213e1 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/_meta.json +++ b/sdk/keyvault/azure-mgmt-keyvault/_meta.json @@ -1,12 +1,12 @@ { - "commit": "2608e811fafd18657b224a0d59e1c3924a534adb", + "commit": "abb6e478adfa345927a67ccb6e7e0ba705a2a455", "repository_url": "https://github.com/Azure/azure-rest-api-specs", "autorest": "3.10.2", "use": [ - "@autorest/python@6.15.0", + "@autorest/python@6.27.4", "@autorest/modelerfour@4.27.0" ], - "autorest_command": "autorest specification/keyvault/resource-manager/readme.md --generate-sample=True --generate-test=True --include-x-ms-examples-original-file=True --python --python-sdks-folder=/home/vsts/work/1/azure-sdk-for-python/sdk --use=@autorest/python@6.15.0 --use=@autorest/modelerfour@4.27.0 --version=3.10.2 --version-tolerant=False", + "autorest_command": "autorest specification/keyvault/resource-manager/readme.md --generate-sample=True --generate-test=True --include-x-ms-examples-original-file=True --python --python-sdks-folder=/mnt/vss/_work/1/s/azure-sdk-for-python/sdk --use=@autorest/python@6.27.4 --use=@autorest/modelerfour@4.27.0 --version=3.10.2 --version-tolerant=False", "readme": "specification/keyvault/resource-manager/readme.md", "package-2019-09": "2021-07-15 01:23:27 -0700 4fe5435a25386ee460ba89817465c7deba818284 Microsoft.KeyVault/stable/2019-09-01/keyvault.json", "package-2018-02": "2020-11-03 15:27:00 -0500 111dab2fbec96b208a78b36bb8dcefd958036476 Microsoft.KeyVault/preview/2018-02-14-preview/keyvault.json", diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/_key_vault_management_client.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/_key_vault_management_client.py index 96b72dbd700b..3c8a258c1d82 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/_key_vault_management_client.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/_key_vault_management_client.py @@ -56,7 +56,7 @@ class KeyVaultManagementClient(MultiApiClientMixin, _SDKClient): :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present. """ - DEFAULT_API_VERSION = '2023-07-01' + DEFAULT_API_VERSION = '2024-11-01' _PROFILE_TAG = "azure.mgmt.keyvault.KeyVaultManagementClient" LATEST_PROFILE = ProfileDefinition({ _PROFILE_TAG: { @@ -95,7 +95,7 @@ def __init__( policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, self._config.http_logging_policy, ] - self._client = ARMPipelineClient(base_url=base_url, policies=_policies, **kwargs) + self._client: ARMPipelineClient = ARMPipelineClient(base_url=base_url, policies=_policies, **kwargs) super(KeyVaultManagementClient, self).__init__( api_version=api_version, profile=profile @@ -110,45 +110,17 @@ def models(cls, api_version=DEFAULT_API_VERSION): """Module depends on the API version: * 2016-10-01: :mod:`v2016_10_01.models` - * 2018-02-14: :mod:`v2018_02_14.models` - * 2019-09-01: :mod:`v2019_09_01.models` - * 2020-04-01-preview: :mod:`v2020_04_01_preview.models` - * 2021-04-01-preview: :mod:`v2021_04_01_preview.models` - * 2021-06-01-preview: :mod:`v2021_06_01_preview.models` - * 2021-10-01: :mod:`v2021_10_01.models` - * 2022-07-01: :mod:`v2022_07_01.models` * 2023-02-01: :mod:`v2023_02_01.models` - * 2023-07-01: :mod:`v2023_07_01.models` + * 2024-11-01: :mod:`v2024_11_01.models` """ if api_version == '2016-10-01': from .v2016_10_01 import models return models - elif api_version == '2018-02-14': - from .v2018_02_14 import models - return models - elif api_version == '2019-09-01': - from .v2019_09_01 import models - return models - elif api_version == '2020-04-01-preview': - from .v2020_04_01_preview import models - return models - elif api_version == '2021-04-01-preview': - from .v2021_04_01_preview import models - return models - elif api_version == '2021-06-01-preview': - from .v2021_06_01_preview import models - return models - elif api_version == '2021-10-01': - from .v2021_10_01 import models - return models - elif api_version == '2022-07-01': - from .v2022_07_01 import models - return models elif api_version == '2023-02-01': from .v2023_02_01 import models return models - elif api_version == '2023-07-01': - from .v2023_07_01 import models + elif api_version == '2024-11-01': + from .v2024_11_01 import models return models raise ValueError("API version {} is not available".format(api_version)) @@ -156,29 +128,14 @@ def models(cls, api_version=DEFAULT_API_VERSION): def keys(self): """Instance depends on the API version: - * 2019-09-01: :class:`KeysOperations` - * 2020-04-01-preview: :class:`KeysOperations` - * 2021-06-01-preview: :class:`KeysOperations` - * 2021-10-01: :class:`KeysOperations` - * 2022-07-01: :class:`KeysOperations` * 2023-02-01: :class:`KeysOperations` - * 2023-07-01: :class:`KeysOperations` + * 2024-11-01: :class:`KeysOperations` """ api_version = self._get_api_version('keys') - if api_version == '2019-09-01': - from .v2019_09_01.operations import KeysOperations as OperationClass - elif api_version == '2020-04-01-preview': - from .v2020_04_01_preview.operations import KeysOperations as OperationClass - elif api_version == '2021-06-01-preview': - from .v2021_06_01_preview.operations import KeysOperations as OperationClass - elif api_version == '2021-10-01': - from .v2021_10_01.operations import KeysOperations as OperationClass - elif api_version == '2022-07-01': - from .v2022_07_01.operations import KeysOperations as OperationClass - elif api_version == '2023-02-01': + if api_version == '2023-02-01': from .v2023_02_01.operations import KeysOperations as OperationClass - elif api_version == '2023-07-01': - from .v2023_07_01.operations import KeysOperations as OperationClass + elif api_version == '2024-11-01': + from .v2024_11_01.operations import KeysOperations as OperationClass else: raise ValueError("API version {} does not have operation group 'keys'".format(api_version)) self._config.api_version = api_version @@ -189,13 +146,13 @@ def managed_hsm_keys(self): """Instance depends on the API version: * 2023-02-01: :class:`ManagedHsmKeysOperations` - * 2023-07-01: :class:`ManagedHsmKeysOperations` + * 2024-11-01: :class:`ManagedHsmKeysOperations` """ api_version = self._get_api_version('managed_hsm_keys') if api_version == '2023-02-01': from .v2023_02_01.operations import ManagedHsmKeysOperations as OperationClass - elif api_version == '2023-07-01': - from .v2023_07_01.operations import ManagedHsmKeysOperations as OperationClass + elif api_version == '2024-11-01': + from .v2024_11_01.operations import ManagedHsmKeysOperations as OperationClass else: raise ValueError("API version {} does not have operation group 'managed_hsm_keys'".format(api_version)) self._config.api_version = api_version @@ -205,29 +162,14 @@ def managed_hsm_keys(self): def managed_hsms(self): """Instance depends on the API version: - * 2020-04-01-preview: :class:`ManagedHsmsOperations` - * 2021-04-01-preview: :class:`ManagedHsmsOperations` - * 2021-06-01-preview: :class:`ManagedHsmsOperations` - * 2021-10-01: :class:`ManagedHsmsOperations` - * 2022-07-01: :class:`ManagedHsmsOperations` * 2023-02-01: :class:`ManagedHsmsOperations` - * 2023-07-01: :class:`ManagedHsmsOperations` + * 2024-11-01: :class:`ManagedHsmsOperations` """ api_version = self._get_api_version('managed_hsms') - if api_version == '2020-04-01-preview': - from .v2020_04_01_preview.operations import ManagedHsmsOperations as OperationClass - elif api_version == '2021-04-01-preview': - from .v2021_04_01_preview.operations import ManagedHsmsOperations as OperationClass - elif api_version == '2021-06-01-preview': - from .v2021_06_01_preview.operations import ManagedHsmsOperations as OperationClass - elif api_version == '2021-10-01': - from .v2021_10_01.operations import ManagedHsmsOperations as OperationClass - elif api_version == '2022-07-01': - from .v2022_07_01.operations import ManagedHsmsOperations as OperationClass - elif api_version == '2023-02-01': + if api_version == '2023-02-01': from .v2023_02_01.operations import ManagedHsmsOperations as OperationClass - elif api_version == '2023-07-01': - from .v2023_07_01.operations import ManagedHsmsOperations as OperationClass + elif api_version == '2024-11-01': + from .v2024_11_01.operations import ManagedHsmsOperations as OperationClass else: raise ValueError("API version {} does not have operation group 'managed_hsms'".format(api_version)) self._config.api_version = api_version @@ -237,26 +179,14 @@ def managed_hsms(self): def mhsm_private_endpoint_connections(self): """Instance depends on the API version: - * 2021-04-01-preview: :class:`MHSMPrivateEndpointConnectionsOperations` - * 2021-06-01-preview: :class:`MHSMPrivateEndpointConnectionsOperations` - * 2021-10-01: :class:`MHSMPrivateEndpointConnectionsOperations` - * 2022-07-01: :class:`MHSMPrivateEndpointConnectionsOperations` * 2023-02-01: :class:`MHSMPrivateEndpointConnectionsOperations` - * 2023-07-01: :class:`MHSMPrivateEndpointConnectionsOperations` + * 2024-11-01: :class:`MHSMPrivateEndpointConnectionsOperations` """ api_version = self._get_api_version('mhsm_private_endpoint_connections') - if api_version == '2021-04-01-preview': - from .v2021_04_01_preview.operations import MHSMPrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2021-06-01-preview': - from .v2021_06_01_preview.operations import MHSMPrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2021-10-01': - from .v2021_10_01.operations import MHSMPrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2022-07-01': - from .v2022_07_01.operations import MHSMPrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2023-02-01': + if api_version == '2023-02-01': from .v2023_02_01.operations import MHSMPrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2023-07-01': - from .v2023_07_01.operations import MHSMPrivateEndpointConnectionsOperations as OperationClass + elif api_version == '2024-11-01': + from .v2024_11_01.operations import MHSMPrivateEndpointConnectionsOperations as OperationClass else: raise ValueError("API version {} does not have operation group 'mhsm_private_endpoint_connections'".format(api_version)) self._config.api_version = api_version @@ -266,26 +196,14 @@ def mhsm_private_endpoint_connections(self): def mhsm_private_link_resources(self): """Instance depends on the API version: - * 2021-04-01-preview: :class:`MHSMPrivateLinkResourcesOperations` - * 2021-06-01-preview: :class:`MHSMPrivateLinkResourcesOperations` - * 2021-10-01: :class:`MHSMPrivateLinkResourcesOperations` - * 2022-07-01: :class:`MHSMPrivateLinkResourcesOperations` * 2023-02-01: :class:`MHSMPrivateLinkResourcesOperations` - * 2023-07-01: :class:`MHSMPrivateLinkResourcesOperations` + * 2024-11-01: :class:`MHSMPrivateLinkResourcesOperations` """ api_version = self._get_api_version('mhsm_private_link_resources') - if api_version == '2021-04-01-preview': - from .v2021_04_01_preview.operations import MHSMPrivateLinkResourcesOperations as OperationClass - elif api_version == '2021-06-01-preview': - from .v2021_06_01_preview.operations import MHSMPrivateLinkResourcesOperations as OperationClass - elif api_version == '2021-10-01': - from .v2021_10_01.operations import MHSMPrivateLinkResourcesOperations as OperationClass - elif api_version == '2022-07-01': - from .v2022_07_01.operations import MHSMPrivateLinkResourcesOperations as OperationClass - elif api_version == '2023-02-01': + if api_version == '2023-02-01': from .v2023_02_01.operations import MHSMPrivateLinkResourcesOperations as OperationClass - elif api_version == '2023-07-01': - from .v2023_07_01.operations import MHSMPrivateLinkResourcesOperations as OperationClass + elif api_version == '2024-11-01': + from .v2024_11_01.operations import MHSMPrivateLinkResourcesOperations as OperationClass else: raise ValueError("API version {} does not have operation group 'mhsm_private_link_resources'".format(api_version)) self._config.api_version = api_version @@ -296,13 +214,13 @@ def mhsm_regions(self): """Instance depends on the API version: * 2023-02-01: :class:`MHSMRegionsOperations` - * 2023-07-01: :class:`MHSMRegionsOperations` + * 2024-11-01: :class:`MHSMRegionsOperations` """ api_version = self._get_api_version('mhsm_regions') if api_version == '2023-02-01': from .v2023_02_01.operations import MHSMRegionsOperations as OperationClass - elif api_version == '2023-07-01': - from .v2023_07_01.operations import MHSMRegionsOperations as OperationClass + elif api_version == '2024-11-01': + from .v2024_11_01.operations import MHSMRegionsOperations as OperationClass else: raise ValueError("API version {} does not have operation group 'mhsm_regions'".format(api_version)) self._config.api_version = api_version @@ -313,37 +231,16 @@ def operations(self): """Instance depends on the API version: * 2016-10-01: :class:`Operations` - * 2018-02-14: :class:`Operations` - * 2019-09-01: :class:`Operations` - * 2020-04-01-preview: :class:`Operations` - * 2021-04-01-preview: :class:`Operations` - * 2021-06-01-preview: :class:`Operations` - * 2021-10-01: :class:`Operations` - * 2022-07-01: :class:`Operations` * 2023-02-01: :class:`Operations` - * 2023-07-01: :class:`Operations` + * 2024-11-01: :class:`Operations` """ api_version = self._get_api_version('operations') if api_version == '2016-10-01': from .v2016_10_01.operations import Operations as OperationClass - elif api_version == '2018-02-14': - from .v2018_02_14.operations import Operations as OperationClass - elif api_version == '2019-09-01': - from .v2019_09_01.operations import Operations as OperationClass - elif api_version == '2020-04-01-preview': - from .v2020_04_01_preview.operations import Operations as OperationClass - elif api_version == '2021-04-01-preview': - from .v2021_04_01_preview.operations import Operations as OperationClass - elif api_version == '2021-06-01-preview': - from .v2021_06_01_preview.operations import Operations as OperationClass - elif api_version == '2021-10-01': - from .v2021_10_01.operations import Operations as OperationClass - elif api_version == '2022-07-01': - from .v2022_07_01.operations import Operations as OperationClass elif api_version == '2023-02-01': from .v2023_02_01.operations import Operations as OperationClass - elif api_version == '2023-07-01': - from .v2023_07_01.operations import Operations as OperationClass + elif api_version == '2024-11-01': + from .v2024_11_01.operations import Operations as OperationClass else: raise ValueError("API version {} does not have operation group 'operations'".format(api_version)) self._config.api_version = api_version @@ -353,35 +250,14 @@ def operations(self): def private_endpoint_connections(self): """Instance depends on the API version: - * 2018-02-14: :class:`PrivateEndpointConnectionsOperations` - * 2019-09-01: :class:`PrivateEndpointConnectionsOperations` - * 2020-04-01-preview: :class:`PrivateEndpointConnectionsOperations` - * 2021-04-01-preview: :class:`PrivateEndpointConnectionsOperations` - * 2021-06-01-preview: :class:`PrivateEndpointConnectionsOperations` - * 2021-10-01: :class:`PrivateEndpointConnectionsOperations` - * 2022-07-01: :class:`PrivateEndpointConnectionsOperations` * 2023-02-01: :class:`PrivateEndpointConnectionsOperations` - * 2023-07-01: :class:`PrivateEndpointConnectionsOperations` + * 2024-11-01: :class:`PrivateEndpointConnectionsOperations` """ api_version = self._get_api_version('private_endpoint_connections') - if api_version == '2018-02-14': - from .v2018_02_14.operations import PrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2019-09-01': - from .v2019_09_01.operations import PrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2020-04-01-preview': - from .v2020_04_01_preview.operations import PrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2021-04-01-preview': - from .v2021_04_01_preview.operations import PrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2021-06-01-preview': - from .v2021_06_01_preview.operations import PrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2021-10-01': - from .v2021_10_01.operations import PrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2022-07-01': - from .v2022_07_01.operations import PrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2023-02-01': + if api_version == '2023-02-01': from .v2023_02_01.operations import PrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2023-07-01': - from .v2023_07_01.operations import PrivateEndpointConnectionsOperations as OperationClass + elif api_version == '2024-11-01': + from .v2024_11_01.operations import PrivateEndpointConnectionsOperations as OperationClass else: raise ValueError("API version {} does not have operation group 'private_endpoint_connections'".format(api_version)) self._config.api_version = api_version @@ -391,35 +267,14 @@ def private_endpoint_connections(self): def private_link_resources(self): """Instance depends on the API version: - * 2018-02-14: :class:`PrivateLinkResourcesOperations` - * 2019-09-01: :class:`PrivateLinkResourcesOperations` - * 2020-04-01-preview: :class:`PrivateLinkResourcesOperations` - * 2021-04-01-preview: :class:`PrivateLinkResourcesOperations` - * 2021-06-01-preview: :class:`PrivateLinkResourcesOperations` - * 2021-10-01: :class:`PrivateLinkResourcesOperations` - * 2022-07-01: :class:`PrivateLinkResourcesOperations` * 2023-02-01: :class:`PrivateLinkResourcesOperations` - * 2023-07-01: :class:`PrivateLinkResourcesOperations` + * 2024-11-01: :class:`PrivateLinkResourcesOperations` """ api_version = self._get_api_version('private_link_resources') - if api_version == '2018-02-14': - from .v2018_02_14.operations import PrivateLinkResourcesOperations as OperationClass - elif api_version == '2019-09-01': - from .v2019_09_01.operations import PrivateLinkResourcesOperations as OperationClass - elif api_version == '2020-04-01-preview': - from .v2020_04_01_preview.operations import PrivateLinkResourcesOperations as OperationClass - elif api_version == '2021-04-01-preview': - from .v2021_04_01_preview.operations import PrivateLinkResourcesOperations as OperationClass - elif api_version == '2021-06-01-preview': - from .v2021_06_01_preview.operations import PrivateLinkResourcesOperations as OperationClass - elif api_version == '2021-10-01': - from .v2021_10_01.operations import PrivateLinkResourcesOperations as OperationClass - elif api_version == '2022-07-01': - from .v2022_07_01.operations import PrivateLinkResourcesOperations as OperationClass - elif api_version == '2023-02-01': + if api_version == '2023-02-01': from .v2023_02_01.operations import PrivateLinkResourcesOperations as OperationClass - elif api_version == '2023-07-01': - from .v2023_07_01.operations import PrivateLinkResourcesOperations as OperationClass + elif api_version == '2024-11-01': + from .v2024_11_01.operations import PrivateLinkResourcesOperations as OperationClass else: raise ValueError("API version {} does not have operation group 'private_link_resources'".format(api_version)) self._config.api_version = api_version @@ -429,26 +284,14 @@ def private_link_resources(self): def secrets(self): """Instance depends on the API version: - * 2020-04-01-preview: :class:`SecretsOperations` - * 2021-06-01-preview: :class:`SecretsOperations` - * 2021-10-01: :class:`SecretsOperations` - * 2022-07-01: :class:`SecretsOperations` * 2023-02-01: :class:`SecretsOperations` - * 2023-07-01: :class:`SecretsOperations` + * 2024-11-01: :class:`SecretsOperations` """ api_version = self._get_api_version('secrets') - if api_version == '2020-04-01-preview': - from .v2020_04_01_preview.operations import SecretsOperations as OperationClass - elif api_version == '2021-06-01-preview': - from .v2021_06_01_preview.operations import SecretsOperations as OperationClass - elif api_version == '2021-10-01': - from .v2021_10_01.operations import SecretsOperations as OperationClass - elif api_version == '2022-07-01': - from .v2022_07_01.operations import SecretsOperations as OperationClass - elif api_version == '2023-02-01': + if api_version == '2023-02-01': from .v2023_02_01.operations import SecretsOperations as OperationClass - elif api_version == '2023-07-01': - from .v2023_07_01.operations import SecretsOperations as OperationClass + elif api_version == '2024-11-01': + from .v2024_11_01.operations import SecretsOperations as OperationClass else: raise ValueError("API version {} does not have operation group 'secrets'".format(api_version)) self._config.api_version = api_version @@ -459,37 +302,16 @@ def vaults(self): """Instance depends on the API version: * 2016-10-01: :class:`VaultsOperations` - * 2018-02-14: :class:`VaultsOperations` - * 2019-09-01: :class:`VaultsOperations` - * 2020-04-01-preview: :class:`VaultsOperations` - * 2021-04-01-preview: :class:`VaultsOperations` - * 2021-06-01-preview: :class:`VaultsOperations` - * 2021-10-01: :class:`VaultsOperations` - * 2022-07-01: :class:`VaultsOperations` * 2023-02-01: :class:`VaultsOperations` - * 2023-07-01: :class:`VaultsOperations` + * 2024-11-01: :class:`VaultsOperations` """ api_version = self._get_api_version('vaults') if api_version == '2016-10-01': from .v2016_10_01.operations import VaultsOperations as OperationClass - elif api_version == '2018-02-14': - from .v2018_02_14.operations import VaultsOperations as OperationClass - elif api_version == '2019-09-01': - from .v2019_09_01.operations import VaultsOperations as OperationClass - elif api_version == '2020-04-01-preview': - from .v2020_04_01_preview.operations import VaultsOperations as OperationClass - elif api_version == '2021-04-01-preview': - from .v2021_04_01_preview.operations import VaultsOperations as OperationClass - elif api_version == '2021-06-01-preview': - from .v2021_06_01_preview.operations import VaultsOperations as OperationClass - elif api_version == '2021-10-01': - from .v2021_10_01.operations import VaultsOperations as OperationClass - elif api_version == '2022-07-01': - from .v2022_07_01.operations import VaultsOperations as OperationClass elif api_version == '2023-02-01': from .v2023_02_01.operations import VaultsOperations as OperationClass - elif api_version == '2023-07-01': - from .v2023_07_01.operations import VaultsOperations as OperationClass + elif api_version == '2024-11-01': + from .v2024_11_01.operations import VaultsOperations as OperationClass else: raise ValueError("API version {} does not have operation group 'vaults'".format(api_version)) self._config.api_version = api_version diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/_serialization.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/_serialization.py index 59f1fcf71bc9..a94487cbf17a 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/_serialization.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/_serialization.py @@ -24,7 +24,6 @@ # # -------------------------------------------------------------------------- -# pylint: skip-file # pyright: reportUnnecessaryTypeIgnoreComment=false from base64 import b64decode, b64encode @@ -52,7 +51,6 @@ MutableMapping, Type, List, - Mapping, ) try: @@ -91,6 +89,8 @@ def deserialize_from_text(cls, data: Optional[Union[AnyStr, IO]], content_type: :param data: Input, could be bytes or stream (will be decoded with UTF8) or text :type data: str or bytes or IO :param str content_type: The content type. + :return: The deserialized data. + :rtype: object """ if hasattr(data, "read"): # Assume a stream @@ -112,7 +112,7 @@ def deserialize_from_text(cls, data: Optional[Union[AnyStr, IO]], content_type: try: return json.loads(data_as_str) except ValueError as err: - raise DeserializationError("JSON is invalid: {}".format(err), err) + raise DeserializationError("JSON is invalid: {}".format(err), err) from err elif "xml" in (content_type or []): try: @@ -155,6 +155,11 @@ def deserialize_from_http_generics(cls, body_bytes: Optional[Union[AnyStr, IO]], Use bytes and headers to NOT use any requests/aiohttp or whatever specific implementation. Headers will tested for "content-type" + + :param bytes body_bytes: The body of the response. + :param dict headers: The headers of the response. + :returns: The deserialized data. + :rtype: object """ # Try to use content-type from headers if available content_type = None @@ -184,15 +189,30 @@ class UTC(datetime.tzinfo): """Time Zone info for handling UTC""" def utcoffset(self, dt): - """UTF offset for UTC is 0.""" + """UTF offset for UTC is 0. + + :param datetime.datetime dt: The datetime + :returns: The offset + :rtype: datetime.timedelta + """ return datetime.timedelta(0) def tzname(self, dt): - """Timestamp representation.""" + """Timestamp representation. + + :param datetime.datetime dt: The datetime + :returns: The timestamp representation + :rtype: str + """ return "Z" def dst(self, dt): - """No daylight saving for UTC.""" + """No daylight saving for UTC. + + :param datetime.datetime dt: The datetime + :returns: The daylight saving time + :rtype: datetime.timedelta + """ return datetime.timedelta(hours=1) @@ -206,7 +226,7 @@ class _FixedOffset(datetime.tzinfo): # type: ignore :param datetime.timedelta offset: offset in timedelta format """ - def __init__(self, offset): + def __init__(self, offset) -> None: self.__offset = offset def utcoffset(self, dt): @@ -235,24 +255,26 @@ def __getinitargs__(self): _FLATTEN = re.compile(r"(? None: self.additional_properties: Optional[Dict[str, Any]] = {} - for k in kwargs: + for k in kwargs: # pylint: disable=consider-using-dict-items if k not in self._attribute_map: _LOGGER.warning("%s is not a known attribute of class %s and will be ignored", k, self.__class__) elif k in self._validation and self._validation[k].get("readonly", False): @@ -300,13 +329,23 @@ def __init__(self, **kwargs: Any) -> None: setattr(self, k, kwargs[k]) def __eq__(self, other: Any) -> bool: - """Compare objects by comparing all attributes.""" + """Compare objects by comparing all attributes. + + :param object other: The object to compare + :returns: True if objects are equal + :rtype: bool + """ if isinstance(other, self.__class__): return self.__dict__ == other.__dict__ return False def __ne__(self, other: Any) -> bool: - """Compare objects by comparing all attributes.""" + """Compare objects by comparing all attributes. + + :param object other: The object to compare + :returns: True if objects are not equal + :rtype: bool + """ return not self.__eq__(other) def __str__(self) -> str: @@ -326,7 +365,11 @@ def is_xml_model(cls) -> bool: @classmethod def _create_xml_node(cls): - """Create XML node.""" + """Create XML node. + + :returns: The XML node + :rtype: xml.etree.ElementTree.Element + """ try: xml_map = cls._xml_map # type: ignore except AttributeError: @@ -346,14 +389,14 @@ def serialize(self, keep_readonly: bool = False, **kwargs: Any) -> JSON: :rtype: dict """ serializer = Serializer(self._infer_class_models()) - return serializer._serialize(self, keep_readonly=keep_readonly, **kwargs) # type: ignore + return serializer._serialize( # type: ignore # pylint: disable=protected-access + self, keep_readonly=keep_readonly, **kwargs + ) def as_dict( self, keep_readonly: bool = True, - key_transformer: Callable[ - [str, Dict[str, Any], Any], Any - ] = attribute_transformer, + key_transformer: Callable[[str, Dict[str, Any], Any], Any] = attribute_transformer, **kwargs: Any ) -> JSON: """Return a dict that can be serialized using json.dump. @@ -382,12 +425,15 @@ def my_key_transformer(key, attr_desc, value): If you want XML serialization, you can pass the kwargs is_xml=True. + :param bool keep_readonly: If you want to serialize the readonly attributes :param function key_transformer: A key transformer function. :returns: A dict JSON compatible object :rtype: dict """ serializer = Serializer(self._infer_class_models()) - return serializer._serialize(self, key_transformer=key_transformer, keep_readonly=keep_readonly, **kwargs) # type: ignore + return serializer._serialize( # type: ignore # pylint: disable=protected-access + self, key_transformer=key_transformer, keep_readonly=keep_readonly, **kwargs + ) @classmethod def _infer_class_models(cls): @@ -397,7 +443,7 @@ def _infer_class_models(cls): client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} if cls.__name__ not in client_models: raise ValueError("Not Autorest generated code") - except Exception: + except Exception: # pylint: disable=broad-exception-caught # Assume it's not Autorest generated (tests?). Add ourselves as dependencies. client_models = {cls.__name__: cls} return client_models @@ -410,6 +456,7 @@ def deserialize(cls: Type[ModelType], data: Any, content_type: Optional[str] = N :param str content_type: JSON by default, set application/xml if XML. :returns: An instance of this model :raises: DeserializationError if something went wrong + :rtype: ModelType """ deserializer = Deserializer(cls._infer_class_models()) return deserializer(cls.__name__, data, content_type=content_type) # type: ignore @@ -428,9 +475,11 @@ def from_dict( and last_rest_key_case_insensitive_extractor) :param dict data: A dict using RestAPI structure + :param function key_extractors: A key extractor function. :param str content_type: JSON by default, set application/xml if XML. :returns: An instance of this model :raises: DeserializationError if something went wrong + :rtype: ModelType """ deserializer = Deserializer(cls._infer_class_models()) deserializer.key_extractors = ( # type: ignore @@ -450,21 +499,25 @@ def _flatten_subtype(cls, key, objects): return {} result = dict(cls._subtype_map[key]) for valuetype in cls._subtype_map[key].values(): - result.update(objects[valuetype]._flatten_subtype(key, objects)) + result.update(objects[valuetype]._flatten_subtype(key, objects)) # pylint: disable=protected-access return result @classmethod def _classify(cls, response, objects): """Check the class _subtype_map for any child classes. We want to ignore any inherited _subtype_maps. - Remove the polymorphic key from the initial data. + + :param dict response: The initial data + :param dict objects: The class objects + :returns: The class to be used + :rtype: class """ for subtype_key in cls.__dict__.get("_subtype_map", {}).keys(): subtype_value = None if not isinstance(response, ET.Element): rest_api_response_key = cls._get_rest_key_parts(subtype_key)[-1] - subtype_value = response.pop(rest_api_response_key, None) or response.pop(subtype_key, None) + subtype_value = response.get(rest_api_response_key, None) or response.get(subtype_key, None) else: subtype_value = xml_key_extractor(subtype_key, cls._attribute_map[subtype_key], response) if subtype_value: @@ -503,11 +556,13 @@ def _decode_attribute_map_key(key): inside the received data. :param str key: A key string from the generated code + :returns: The decoded key + :rtype: str """ return key.replace("\\.", ".") -class Serializer(object): +class Serializer: # pylint: disable=too-many-public-methods """Request object model serializer.""" basic_types = {str: "str", int: "int", bool: "bool", float: "float"} @@ -542,7 +597,7 @@ class Serializer(object): "multiple": lambda x, y: x % y != 0, } - def __init__(self, classes: Optional[Mapping[str, type]]=None): + def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None: self.serialize_type = { "iso-8601": Serializer.serialize_iso, "rfc-1123": Serializer.serialize_rfc, @@ -562,13 +617,16 @@ def __init__(self, classes: Optional[Mapping[str, type]]=None): self.key_transformer = full_restapi_key_transformer self.client_side_validation = True - def _serialize(self, target_obj, data_type=None, **kwargs): + def _serialize( # pylint: disable=too-many-nested-blocks, too-many-branches, too-many-statements, too-many-locals + self, target_obj, data_type=None, **kwargs + ): """Serialize data into a string according to type. - :param target_obj: The data to be serialized. + :param object target_obj: The data to be serialized. :param str data_type: The type to be serialized from. :rtype: str, dict :raises: SerializationError if serialization fails. + :returns: The serialized data. """ key_transformer = kwargs.get("key_transformer", self.key_transformer) keep_readonly = kwargs.get("keep_readonly", False) @@ -594,12 +652,14 @@ def _serialize(self, target_obj, data_type=None, **kwargs): serialized = {} if is_xml_model_serialization: - serialized = target_obj._create_xml_node() + serialized = target_obj._create_xml_node() # pylint: disable=protected-access try: - attributes = target_obj._attribute_map + attributes = target_obj._attribute_map # pylint: disable=protected-access for attr, attr_desc in attributes.items(): attr_name = attr - if not keep_readonly and target_obj._validation.get(attr_name, {}).get("readonly", False): + if not keep_readonly and target_obj._validation.get( # pylint: disable=protected-access + attr_name, {} + ).get("readonly", False): continue if attr_name == "additional_properties" and attr_desc["key"] == "": @@ -635,7 +695,8 @@ def _serialize(self, target_obj, data_type=None, **kwargs): if isinstance(new_attr, list): serialized.extend(new_attr) # type: ignore elif isinstance(new_attr, ET.Element): - # If the down XML has no XML/Name, we MUST replace the tag with the local tag. But keeping the namespaces. + # If the down XML has no XML/Name, + # we MUST replace the tag with the local tag. But keeping the namespaces. if "name" not in getattr(orig_attr, "_xml_map", {}): splitted_tag = new_attr.tag.split("}") if len(splitted_tag) == 2: # Namespace @@ -666,17 +727,17 @@ def _serialize(self, target_obj, data_type=None, **kwargs): except (AttributeError, KeyError, TypeError) as err: msg = "Attribute {} in object {} cannot be serialized.\n{}".format(attr_name, class_name, str(target_obj)) raise SerializationError(msg) from err - else: - return serialized + return serialized def body(self, data, data_type, **kwargs): """Serialize data intended for a request body. - :param data: The data to be serialized. + :param object data: The data to be serialized. :param str data_type: The type to be serialized from. :rtype: dict :raises: SerializationError if serialization fails. :raises: ValueError if data is None + :returns: The serialized request body """ # Just in case this is a dict @@ -705,7 +766,7 @@ def body(self, data, data_type, **kwargs): attribute_key_case_insensitive_extractor, last_rest_key_case_insensitive_extractor, ] - data = deserializer._deserialize(data_type, data) + data = deserializer._deserialize(data_type, data) # pylint: disable=protected-access except DeserializationError as err: raise SerializationError("Unable to build a model: " + str(err)) from err @@ -714,9 +775,11 @@ def body(self, data, data_type, **kwargs): def url(self, name, data, data_type, **kwargs): """Serialize data intended for a URL path. - :param data: The data to be serialized. + :param str name: The name of the URL path parameter. + :param object data: The data to be serialized. :param str data_type: The type to be serialized from. :rtype: str + :returns: The serialized URL path :raises: TypeError if serialization fails. :raises: ValueError if data is None """ @@ -730,27 +793,26 @@ def url(self, name, data, data_type, **kwargs): output = output.replace("{", quote("{")).replace("}", quote("}")) else: output = quote(str(output), safe="") - except SerializationError: - raise TypeError("{} must be type {}.".format(name, data_type)) - else: - return output + except SerializationError as exc: + raise TypeError("{} must be type {}.".format(name, data_type)) from exc + return output def query(self, name, data, data_type, **kwargs): """Serialize data intended for a URL query. - :param data: The data to be serialized. + :param str name: The name of the query parameter. + :param object data: The data to be serialized. :param str data_type: The type to be serialized from. - :keyword bool skip_quote: Whether to skip quote the serialized result. - Defaults to False. :rtype: str, list :raises: TypeError if serialization fails. :raises: ValueError if data is None + :returns: The serialized query parameter """ try: # Treat the list aside, since we don't want to encode the div separator if data_type.startswith("["): internal_data_type = data_type[1:-1] - do_quote = not kwargs.get('skip_quote', False) + do_quote = not kwargs.get("skip_quote", False) return self.serialize_iter(data, internal_data_type, do_quote=do_quote, **kwargs) # Not a list, regular serialization @@ -761,19 +823,20 @@ def query(self, name, data, data_type, **kwargs): output = str(output) else: output = quote(str(output), safe="") - except SerializationError: - raise TypeError("{} must be type {}.".format(name, data_type)) - else: - return str(output) + except SerializationError as exc: + raise TypeError("{} must be type {}.".format(name, data_type)) from exc + return str(output) def header(self, name, data, data_type, **kwargs): """Serialize data intended for a request header. - :param data: The data to be serialized. + :param str name: The name of the header. + :param object data: The data to be serialized. :param str data_type: The type to be serialized from. :rtype: str :raises: TypeError if serialization fails. :raises: ValueError if data is None + :returns: The serialized header """ try: if data_type in ["[str]"]: @@ -782,21 +845,20 @@ def header(self, name, data, data_type, **kwargs): output = self.serialize_data(data, data_type, **kwargs) if data_type == "bool": output = json.dumps(output) - except SerializationError: - raise TypeError("{} must be type {}.".format(name, data_type)) - else: - return str(output) + except SerializationError as exc: + raise TypeError("{} must be type {}.".format(name, data_type)) from exc + return str(output) def serialize_data(self, data, data_type, **kwargs): """Serialize generic data according to supplied data type. - :param data: The data to be serialized. + :param object data: The data to be serialized. :param str data_type: The type to be serialized from. - :param bool required: Whether it's essential that the data not be - empty or None :raises: AttributeError if required data is None. :raises: ValueError if data is None :raises: SerializationError if serialization fails. + :returns: The serialized data. + :rtype: str, int, float, bool, dict, list """ if data is None: raise ValueError("No value for given attribute") @@ -807,7 +869,7 @@ def serialize_data(self, data, data_type, **kwargs): if data_type in self.basic_types.values(): return self.serialize_basic(data, data_type, **kwargs) - elif data_type in self.serialize_type: + if data_type in self.serialize_type: return self.serialize_type[data_type](data, **kwargs) # If dependencies is empty, try with current data class @@ -823,11 +885,10 @@ def serialize_data(self, data, data_type, **kwargs): except (ValueError, TypeError) as err: msg = "Unable to serialize value: {!r} as type: {!r}." raise SerializationError(msg.format(data, data_type)) from err - else: - return self._serialize(data, **kwargs) + return self._serialize(data, **kwargs) @classmethod - def _get_custom_serializers(cls, data_type, **kwargs): + def _get_custom_serializers(cls, data_type, **kwargs): # pylint: disable=inconsistent-return-statements custom_serializer = kwargs.get("basic_types_serializers", {}).get(data_type) if custom_serializer: return custom_serializer @@ -843,23 +904,26 @@ def serialize_basic(cls, data, data_type, **kwargs): - basic_types_serializers dict[str, callable] : If set, use the callable as serializer - is_xml bool : If set, use xml_basic_types_serializers - :param data: Object to be serialized. + :param obj data: Object to be serialized. :param str data_type: Type of object in the iterable. + :rtype: str, int, float, bool + :return: serialized object """ custom_serializer = cls._get_custom_serializers(data_type, **kwargs) if custom_serializer: return custom_serializer(data) if data_type == "str": return cls.serialize_unicode(data) - return eval(data_type)(data) # nosec + return eval(data_type)(data) # nosec # pylint: disable=eval-used @classmethod def serialize_unicode(cls, data): """Special handling for serializing unicode strings in Py2. Encode to UTF-8 if unicode, otherwise handle as a str. - :param data: Object to be serialized. + :param str data: Object to be serialized. :rtype: str + :return: serialized object """ try: # If I received an enum, return its value return data.value @@ -873,8 +937,7 @@ def serialize_unicode(cls, data): return data except NameError: return str(data) - else: - return str(data) + return str(data) def serialize_iter(self, data, iter_type, div=None, **kwargs): """Serialize iterable. @@ -884,15 +947,13 @@ def serialize_iter(self, data, iter_type, div=None, **kwargs): serialization_ctxt['type'] should be same as data_type. - is_xml bool : If set, serialize as XML - :param list attr: Object to be serialized. + :param list data: Object to be serialized. :param str iter_type: Type of object in the iterable. - :param bool required: Whether the objects in the iterable must - not be None or empty. :param str div: If set, this str will be used to combine the elements in the iterable into a combined string. Default is 'None'. - :keyword bool do_quote: Whether to quote the serialized result of each iterable element. Defaults to False. :rtype: list, str + :return: serialized iterable """ if isinstance(data, str): raise SerializationError("Refuse str type as a valid iter type.") @@ -909,12 +970,8 @@ def serialize_iter(self, data, iter_type, div=None, **kwargs): raise serialized.append(None) - if kwargs.get('do_quote', False): - serialized = [ - '' if s is None else quote(str(s), safe='') - for s - in serialized - ] + if kwargs.get("do_quote", False): + serialized = ["" if s is None else quote(str(s), safe="") for s in serialized] if div: serialized = ["" if s is None else str(s) for s in serialized] @@ -951,9 +1008,8 @@ def serialize_dict(self, attr, dict_type, **kwargs): :param dict attr: Object to be serialized. :param str dict_type: Type of object in the dictionary. - :param bool required: Whether the objects in the dictionary must - not be None or empty. :rtype: dict + :return: serialized dictionary """ serialization_ctxt = kwargs.get("serialization_ctxt", {}) serialized = {} @@ -977,7 +1033,7 @@ def serialize_dict(self, attr, dict_type, **kwargs): return serialized - def serialize_object(self, attr, **kwargs): + def serialize_object(self, attr, **kwargs): # pylint: disable=too-many-return-statements """Serialize a generic object. This will be handled as a dictionary. If object passed in is not a basic type (str, int, float, dict, list) it will simply be @@ -985,6 +1041,7 @@ def serialize_object(self, attr, **kwargs): :param dict attr: Object to be serialized. :rtype: dict or str + :return: serialized object """ if attr is None: return None @@ -1009,7 +1066,7 @@ def serialize_object(self, attr, **kwargs): return self.serialize_decimal(attr) # If it's a model or I know this dependency, serialize as a Model - elif obj_type in self.dependencies.values() or isinstance(attr, Model): + if obj_type in self.dependencies.values() or isinstance(attr, Model): return self._serialize(attr) if obj_type == dict: @@ -1040,56 +1097,61 @@ def serialize_enum(attr, enum_obj=None): try: enum_obj(result) # type: ignore return result - except ValueError: + except ValueError as exc: for enum_value in enum_obj: # type: ignore if enum_value.value.lower() == str(attr).lower(): return enum_value.value error = "{!r} is not valid value for enum {!r}" - raise SerializationError(error.format(attr, enum_obj)) + raise SerializationError(error.format(attr, enum_obj)) from exc @staticmethod - def serialize_bytearray(attr, **kwargs): + def serialize_bytearray(attr, **kwargs): # pylint: disable=unused-argument """Serialize bytearray into base-64 string. - :param attr: Object to be serialized. + :param str attr: Object to be serialized. :rtype: str + :return: serialized base64 """ return b64encode(attr).decode() @staticmethod - def serialize_base64(attr, **kwargs): + def serialize_base64(attr, **kwargs): # pylint: disable=unused-argument """Serialize str into base-64 string. - :param attr: Object to be serialized. + :param str attr: Object to be serialized. :rtype: str + :return: serialized base64 """ encoded = b64encode(attr).decode("ascii") return encoded.strip("=").replace("+", "-").replace("/", "_") @staticmethod - def serialize_decimal(attr, **kwargs): + def serialize_decimal(attr, **kwargs): # pylint: disable=unused-argument """Serialize Decimal object to float. - :param attr: Object to be serialized. + :param decimal attr: Object to be serialized. :rtype: float + :return: serialized decimal """ return float(attr) @staticmethod - def serialize_long(attr, **kwargs): + def serialize_long(attr, **kwargs): # pylint: disable=unused-argument """Serialize long (Py2) or int (Py3). - :param attr: Object to be serialized. + :param int attr: Object to be serialized. :rtype: int/long + :return: serialized long """ return _long_type(attr) @staticmethod - def serialize_date(attr, **kwargs): + def serialize_date(attr, **kwargs): # pylint: disable=unused-argument """Serialize Date object into ISO-8601 formatted string. :param Date attr: Object to be serialized. :rtype: str + :return: serialized date """ if isinstance(attr, str): attr = isodate.parse_date(attr) @@ -1097,11 +1159,12 @@ def serialize_date(attr, **kwargs): return t @staticmethod - def serialize_time(attr, **kwargs): + def serialize_time(attr, **kwargs): # pylint: disable=unused-argument """Serialize Time object into ISO-8601 formatted string. :param datetime.time attr: Object to be serialized. :rtype: str + :return: serialized time """ if isinstance(attr, str): attr = isodate.parse_time(attr) @@ -1111,30 +1174,32 @@ def serialize_time(attr, **kwargs): return t @staticmethod - def serialize_duration(attr, **kwargs): + def serialize_duration(attr, **kwargs): # pylint: disable=unused-argument """Serialize TimeDelta object into ISO-8601 formatted string. :param TimeDelta attr: Object to be serialized. :rtype: str + :return: serialized duration """ if isinstance(attr, str): attr = isodate.parse_duration(attr) return isodate.duration_isoformat(attr) @staticmethod - def serialize_rfc(attr, **kwargs): + def serialize_rfc(attr, **kwargs): # pylint: disable=unused-argument """Serialize Datetime object into RFC-1123 formatted string. :param Datetime attr: Object to be serialized. :rtype: str :raises: TypeError if format invalid. + :return: serialized rfc """ try: if not attr.tzinfo: _LOGGER.warning("Datetime with no tzinfo will be considered UTC.") utc = attr.utctimetuple() - except AttributeError: - raise TypeError("RFC1123 object must be valid Datetime object.") + except AttributeError as exc: + raise TypeError("RFC1123 object must be valid Datetime object.") from exc return "{}, {:02} {} {:04} {:02}:{:02}:{:02} GMT".format( Serializer.days[utc.tm_wday], @@ -1147,12 +1212,13 @@ def serialize_rfc(attr, **kwargs): ) @staticmethod - def serialize_iso(attr, **kwargs): + def serialize_iso(attr, **kwargs): # pylint: disable=unused-argument """Serialize Datetime object into ISO-8601 formatted string. :param Datetime attr: Object to be serialized. :rtype: str :raises: SerializationError if format invalid. + :return: serialized iso """ if isinstance(attr, str): attr = isodate.parse_datetime(attr) @@ -1178,13 +1244,14 @@ def serialize_iso(attr, **kwargs): raise TypeError(msg) from err @staticmethod - def serialize_unix(attr, **kwargs): + def serialize_unix(attr, **kwargs): # pylint: disable=unused-argument """Serialize Datetime object into IntTime format. This is represented as seconds. :param Datetime attr: Object to be serialized. :rtype: int :raises: SerializationError if format invalid + :return: serialied unix """ if isinstance(attr, int): return attr @@ -1192,11 +1259,11 @@ def serialize_unix(attr, **kwargs): if not attr.tzinfo: _LOGGER.warning("Datetime with no tzinfo will be considered UTC.") return int(calendar.timegm(attr.utctimetuple())) - except AttributeError: - raise TypeError("Unix time object must be valid Datetime object.") + except AttributeError as exc: + raise TypeError("Unix time object must be valid Datetime object.") from exc -def rest_key_extractor(attr, attr_desc, data): +def rest_key_extractor(attr, attr_desc, data): # pylint: disable=unused-argument key = attr_desc["key"] working_data = data @@ -1217,7 +1284,9 @@ def rest_key_extractor(attr, attr_desc, data): return working_data.get(key) -def rest_key_case_insensitive_extractor(attr, attr_desc, data): +def rest_key_case_insensitive_extractor( # pylint: disable=unused-argument, inconsistent-return-statements + attr, attr_desc, data +): key = attr_desc["key"] working_data = data @@ -1238,17 +1307,29 @@ def rest_key_case_insensitive_extractor(attr, attr_desc, data): return attribute_key_case_insensitive_extractor(key, None, working_data) -def last_rest_key_extractor(attr, attr_desc, data): - """Extract the attribute in "data" based on the last part of the JSON path key.""" +def last_rest_key_extractor(attr, attr_desc, data): # pylint: disable=unused-argument + """Extract the attribute in "data" based on the last part of the JSON path key. + + :param str attr: The attribute to extract + :param dict attr_desc: The attribute description + :param dict data: The data to extract from + :rtype: object + :returns: The extracted attribute + """ key = attr_desc["key"] dict_keys = _FLATTEN.split(key) return attribute_key_extractor(dict_keys[-1], None, data) -def last_rest_key_case_insensitive_extractor(attr, attr_desc, data): +def last_rest_key_case_insensitive_extractor(attr, attr_desc, data): # pylint: disable=unused-argument """Extract the attribute in "data" based on the last part of the JSON path key. This is the case insensitive version of "last_rest_key_extractor" + :param str attr: The attribute to extract + :param dict attr_desc: The attribute description + :param dict data: The data to extract from + :rtype: object + :returns: The extracted attribute """ key = attr_desc["key"] dict_keys = _FLATTEN.split(key) @@ -1285,7 +1366,7 @@ def _extract_name_from_internal_type(internal_type): return xml_name -def xml_key_extractor(attr, attr_desc, data): +def xml_key_extractor(attr, attr_desc, data): # pylint: disable=unused-argument,too-many-return-statements if isinstance(data, dict): return None @@ -1337,22 +1418,21 @@ def xml_key_extractor(attr, attr_desc, data): if is_iter_type: if is_wrapped: return None # is_wrapped no node, we want None - else: - return [] # not wrapped, assume empty list + return [] # not wrapped, assume empty list return None # Assume it's not there, maybe an optional node. # If is_iter_type and not wrapped, return all found children if is_iter_type: if not is_wrapped: return children - else: # Iter and wrapped, should have found one node only (the wrap one) - if len(children) != 1: - raise DeserializationError( - "Tried to deserialize an array not wrapped, and found several nodes '{}'. Maybe you should declare this array as wrapped?".format( - xml_name - ) + # Iter and wrapped, should have found one node only (the wrap one) + if len(children) != 1: + raise DeserializationError( + "Tried to deserialize an array not wrapped, and found several nodes '{}'. Maybe you should declare this array as wrapped?".format( # pylint: disable=line-too-long + xml_name ) - return list(children[0]) # Might be empty list and that's ok. + ) + return list(children[0]) # Might be empty list and that's ok. # Here it's not a itertype, we should have found one element only or empty if len(children) > 1: @@ -1360,7 +1440,7 @@ def xml_key_extractor(attr, attr_desc, data): return children[0] -class Deserializer(object): +class Deserializer: """Response object model deserializer. :param dict classes: Class type dictionary for deserializing complex types. @@ -1369,9 +1449,9 @@ class Deserializer(object): basic_types = {str: "str", int: "int", bool: "bool", float: "float"} - valid_date = re.compile(r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}" r"\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?") + valid_date = re.compile(r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?") - def __init__(self, classes: Optional[Mapping[str, type]]=None): + def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None: self.deserialize_type = { "iso-8601": Deserializer.deserialize_iso, "rfc-1123": Deserializer.deserialize_rfc, @@ -1409,11 +1489,12 @@ def __call__(self, target_obj, response_data, content_type=None): :param str content_type: Swagger "produces" if available. :raises: DeserializationError if deserialization fails. :return: Deserialized object. + :rtype: object """ data = self._unpack_content(response_data, content_type) return self._deserialize(target_obj, data) - def _deserialize(self, target_obj, data): + def _deserialize(self, target_obj, data): # pylint: disable=inconsistent-return-statements """Call the deserializer on a model. Data needs to be already deserialized as JSON or XML ElementTree @@ -1422,12 +1503,13 @@ def _deserialize(self, target_obj, data): :param object data: Object to deserialize. :raises: DeserializationError if deserialization fails. :return: Deserialized object. + :rtype: object """ # This is already a model, go recursive just in case if hasattr(data, "_attribute_map"): constants = [name for name, config in getattr(data, "_validation", {}).items() if config.get("constant")] try: - for attr, mapconfig in data._attribute_map.items(): + for attr, mapconfig in data._attribute_map.items(): # pylint: disable=protected-access if attr in constants: continue value = getattr(data, attr) @@ -1446,13 +1528,13 @@ def _deserialize(self, target_obj, data): if isinstance(response, str): return self.deserialize_data(data, response) - elif isinstance(response, type) and issubclass(response, Enum): + if isinstance(response, type) and issubclass(response, Enum): return self.deserialize_enum(data, response) if data is None or data is CoreNull: return data try: - attributes = response._attribute_map # type: ignore + attributes = response._attribute_map # type: ignore # pylint: disable=protected-access d_attrs = {} for attr, attr_desc in attributes.items(): # Check empty string. If it's not empty, someone has a real "additionalProperties"... @@ -1482,9 +1564,8 @@ def _deserialize(self, target_obj, data): except (AttributeError, TypeError, KeyError) as err: msg = "Unable to deserialize to object: " + class_name # type: ignore raise DeserializationError(msg) from err - else: - additional_properties = self._build_additional_properties(attributes, data) - return self._instantiate_model(response, d_attrs, additional_properties) + additional_properties = self._build_additional_properties(attributes, data) + return self._instantiate_model(response, d_attrs, additional_properties) def _build_additional_properties(self, attribute_map, data): if not self.additional_properties_detection: @@ -1511,6 +1592,8 @@ def _classify_target(self, target, data): :param str target: The target object type to deserialize to. :param str/dict data: The response data to deserialize. + :return: The classified target object and its class name. + :rtype: tuple """ if target is None: return None, None @@ -1522,7 +1605,7 @@ def _classify_target(self, target, data): return target, target try: - target = target._classify(data, self.dependencies) # type: ignore + target = target._classify(data, self.dependencies) # type: ignore # pylint: disable=protected-access except AttributeError: pass # Target is not a Model, no classify return target, target.__class__.__name__ # type: ignore @@ -1537,10 +1620,12 @@ def failsafe_deserialize(self, target_obj, data, content_type=None): :param str target_obj: The target object type to deserialize to. :param str/dict data: The response data to deserialize. :param str content_type: Swagger "produces" if available. + :return: Deserialized object. + :rtype: object """ try: return self(target_obj, data, content_type=content_type) - except: + except: # pylint: disable=bare-except _LOGGER.debug( "Ran into a deserialization error. Ignoring since this is failsafe deserialization", exc_info=True ) @@ -1558,10 +1643,12 @@ def _unpack_content(raw_data, content_type=None): If raw_data is something else, bypass all logic and return it directly. - :param raw_data: Data to be processed. - :param content_type: How to parse if raw_data is a string/bytes. + :param obj raw_data: Data to be processed. + :param str content_type: How to parse if raw_data is a string/bytes. :raises JSONDecodeError: If JSON is requested and parsing is impossible. :raises UnicodeDecodeError: If bytes is not UTF8 + :rtype: object + :return: Unpacked content. """ # Assume this is enough to detect a Pipeline Response without importing it context = getattr(raw_data, "context", {}) @@ -1585,24 +1672,35 @@ def _unpack_content(raw_data, content_type=None): def _instantiate_model(self, response, attrs, additional_properties=None): """Instantiate a response model passing in deserialized args. - :param response: The response model class. - :param d_attrs: The deserialized response attributes. + :param Response response: The response model class. + :param dict attrs: The deserialized response attributes. + :param dict additional_properties: Additional properties to be set. + :rtype: Response + :return: The instantiated response model. """ if callable(response): subtype = getattr(response, "_subtype_map", {}) try: - readonly = [k for k, v in response._validation.items() if v.get("readonly")] - const = [k for k, v in response._validation.items() if v.get("constant")] + readonly = [ + k + for k, v in response._validation.items() # pylint: disable=protected-access # type: ignore + if v.get("readonly") + ] + const = [ + k + for k, v in response._validation.items() # pylint: disable=protected-access # type: ignore + if v.get("constant") + ] kwargs = {k: v for k, v in attrs.items() if k not in subtype and k not in readonly + const} response_obj = response(**kwargs) for attr in readonly: setattr(response_obj, attr, attrs.get(attr)) if additional_properties: - response_obj.additional_properties = additional_properties + response_obj.additional_properties = additional_properties # type: ignore return response_obj except TypeError as err: msg = "Unable to deserialize {} into model {}. ".format(kwargs, response) # type: ignore - raise DeserializationError(msg + str(err)) + raise DeserializationError(msg + str(err)) from err else: try: for attr, value in attrs.items(): @@ -1611,15 +1709,16 @@ def _instantiate_model(self, response, attrs, additional_properties=None): except Exception as exp: msg = "Unable to populate response model. " msg += "Type: {}, Error: {}".format(type(response), exp) - raise DeserializationError(msg) + raise DeserializationError(msg) from exp - def deserialize_data(self, data, data_type): + def deserialize_data(self, data, data_type): # pylint: disable=too-many-return-statements """Process data for deserialization according to data type. :param str data: The response string to be deserialized. :param str data_type: The type to deserialize to. :raises: DeserializationError if deserialization fails. :return: Deserialized object. + :rtype: object """ if data is None: return data @@ -1633,7 +1732,11 @@ def deserialize_data(self, data, data_type): if isinstance(data, self.deserialize_expected_types.get(data_type, tuple())): return data - is_a_text_parsing_type = lambda x: x not in ["object", "[]", r"{}"] + is_a_text_parsing_type = lambda x: x not in [ # pylint: disable=unnecessary-lambda-assignment + "object", + "[]", + r"{}", + ] if isinstance(data, ET.Element) and is_a_text_parsing_type(data_type) and not data.text: return None data_val = self.deserialize_type[data_type](data) @@ -1653,14 +1756,14 @@ def deserialize_data(self, data, data_type): msg = "Unable to deserialize response data." msg += " Data: {}, {}".format(data, data_type) raise DeserializationError(msg) from err - else: - return self._deserialize(obj_type, data) + return self._deserialize(obj_type, data) def deserialize_iter(self, attr, iter_type): """Deserialize an iterable. :param list attr: Iterable to be deserialized. :param str iter_type: The type of object in the iterable. + :return: Deserialized iterable. :rtype: list """ if attr is None: @@ -1677,6 +1780,7 @@ def deserialize_dict(self, attr, dict_type): :param dict/list attr: Dictionary to be deserialized. Also accepts a list of key, value pairs. :param str dict_type: The object type of the items in the dictionary. + :return: Deserialized dictionary. :rtype: dict """ if isinstance(attr, list): @@ -1687,11 +1791,12 @@ def deserialize_dict(self, attr, dict_type): attr = {el.tag: el.text for el in attr} return {k: self.deserialize_data(v, dict_type) for k, v in attr.items()} - def deserialize_object(self, attr, **kwargs): + def deserialize_object(self, attr, **kwargs): # pylint: disable=too-many-return-statements """Deserialize a generic object. This will be handled as a dictionary. :param dict attr: Dictionary to be deserialized. + :return: Deserialized object. :rtype: dict :raises: TypeError if non-builtin datatype encountered. """ @@ -1726,11 +1831,10 @@ def deserialize_object(self, attr, **kwargs): pass return deserialized - else: - error = "Cannot deserialize generic object with type: " - raise TypeError(error + str(obj_type)) + error = "Cannot deserialize generic object with type: " + raise TypeError(error + str(obj_type)) - def deserialize_basic(self, attr, data_type): + def deserialize_basic(self, attr, data_type): # pylint: disable=too-many-return-statements """Deserialize basic builtin data type from string. Will attempt to convert to str, int, float and bool. This function will also accept '1', '0', 'true' and 'false' as @@ -1738,6 +1842,7 @@ def deserialize_basic(self, attr, data_type): :param str attr: response string to be deserialized. :param str data_type: deserialization data type. + :return: Deserialized basic type. :rtype: str, int, float or bool :raises: TypeError if string format is not valid. """ @@ -1749,24 +1854,23 @@ def deserialize_basic(self, attr, data_type): if data_type == "str": # None or '', node is empty string. return "" - else: - # None or '', node with a strong type is None. - # Don't try to model "empty bool" or "empty int" - return None + # None or '', node with a strong type is None. + # Don't try to model "empty bool" or "empty int" + return None if data_type == "bool": if attr in [True, False, 1, 0]: return bool(attr) - elif isinstance(attr, str): + if isinstance(attr, str): if attr.lower() in ["true", "1"]: return True - elif attr.lower() in ["false", "0"]: + if attr.lower() in ["false", "0"]: return False raise TypeError("Invalid boolean value: {}".format(attr)) if data_type == "str": return self.deserialize_unicode(attr) - return eval(data_type)(attr) # nosec + return eval(data_type)(attr) # nosec # pylint: disable=eval-used @staticmethod def deserialize_unicode(data): @@ -1774,6 +1878,7 @@ def deserialize_unicode(data): as a string. :param str data: response string to be deserialized. + :return: Deserialized string. :rtype: str or unicode """ # We might be here because we have an enum modeled as string, @@ -1787,8 +1892,7 @@ def deserialize_unicode(data): return data except NameError: return str(data) - else: - return str(data) + return str(data) @staticmethod def deserialize_enum(data, enum_obj): @@ -1800,6 +1904,7 @@ def deserialize_enum(data, enum_obj): :param str data: Response string to be deserialized. If this value is None or invalid it will be returned as-is. :param Enum enum_obj: Enum object to deserialize to. + :return: Deserialized enum object. :rtype: Enum """ if isinstance(data, enum_obj) or data is None: @@ -1810,9 +1915,9 @@ def deserialize_enum(data, enum_obj): # Workaround. We might consider remove it in the future. try: return list(enum_obj.__members__.values())[data] - except IndexError: + except IndexError as exc: error = "{!r} is not a valid index for enum {!r}" - raise DeserializationError(error.format(data, enum_obj)) + raise DeserializationError(error.format(data, enum_obj)) from exc try: return enum_obj(str(data)) except ValueError: @@ -1828,6 +1933,7 @@ def deserialize_bytearray(attr): """Deserialize string into bytearray. :param str attr: response string to be deserialized. + :return: Deserialized bytearray :rtype: bytearray :raises: TypeError if string format invalid. """ @@ -1840,6 +1946,7 @@ def deserialize_base64(attr): """Deserialize base64 encoded string into string. :param str attr: response string to be deserialized. + :return: Deserialized base64 string :rtype: bytearray :raises: TypeError if string format invalid. """ @@ -1855,8 +1962,9 @@ def deserialize_decimal(attr): """Deserialize string into Decimal object. :param str attr: response string to be deserialized. - :rtype: Decimal + :return: Deserialized decimal :raises: DeserializationError if string format invalid. + :rtype: decimal """ if isinstance(attr, ET.Element): attr = attr.text @@ -1871,6 +1979,7 @@ def deserialize_long(attr): """Deserialize string into long (Py2) or int (Py3). :param str attr: response string to be deserialized. + :return: Deserialized int :rtype: long or int :raises: ValueError if string format invalid. """ @@ -1883,6 +1992,7 @@ def deserialize_duration(attr): """Deserialize ISO-8601 formatted string into TimeDelta object. :param str attr: response string to be deserialized. + :return: Deserialized duration :rtype: TimeDelta :raises: DeserializationError if string format invalid. """ @@ -1893,14 +2003,14 @@ def deserialize_duration(attr): except (ValueError, OverflowError, AttributeError) as err: msg = "Cannot deserialize duration object." raise DeserializationError(msg) from err - else: - return duration + return duration @staticmethod def deserialize_date(attr): """Deserialize ISO-8601 formatted string into Date object. :param str attr: response string to be deserialized. + :return: Deserialized date :rtype: Date :raises: DeserializationError if string format invalid. """ @@ -1916,6 +2026,7 @@ def deserialize_time(attr): """Deserialize ISO-8601 formatted string into time object. :param str attr: response string to be deserialized. + :return: Deserialized time :rtype: datetime.time :raises: DeserializationError if string format invalid. """ @@ -1930,6 +2041,7 @@ def deserialize_rfc(attr): """Deserialize RFC-1123 formatted string into Datetime object. :param str attr: response string to be deserialized. + :return: Deserialized RFC datetime :rtype: Datetime :raises: DeserializationError if string format invalid. """ @@ -1945,14 +2057,14 @@ def deserialize_rfc(attr): except ValueError as err: msg = "Cannot deserialize to rfc datetime object." raise DeserializationError(msg) from err - else: - return date_obj + return date_obj @staticmethod def deserialize_iso(attr): """Deserialize ISO-8601 formatted string into Datetime object. :param str attr: response string to be deserialized. + :return: Deserialized ISO datetime :rtype: Datetime :raises: DeserializationError if string format invalid. """ @@ -1982,8 +2094,7 @@ def deserialize_iso(attr): except (ValueError, OverflowError, AttributeError) as err: msg = "Cannot deserialize datetime object." raise DeserializationError(msg) from err - else: - return date_obj + return date_obj @staticmethod def deserialize_unix(attr): @@ -1991,6 +2102,7 @@ def deserialize_unix(attr): This is represented as seconds. :param int attr: Object to be serialized. + :return: Deserialized datetime :rtype: Datetime :raises: DeserializationError if format invalid """ @@ -2002,5 +2114,4 @@ def deserialize_unix(attr): except ValueError as err: msg = "Cannot deserialize to unix datetime object." raise DeserializationError(msg) from err - else: - return date_obj + return date_obj diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/aio/_key_vault_management_client.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/aio/_key_vault_management_client.py index 93cfdd3ab632..c29bfabc42b7 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/aio/_key_vault_management_client.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/aio/_key_vault_management_client.py @@ -56,7 +56,7 @@ class KeyVaultManagementClient(MultiApiClientMixin, _SDKClient): :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present. """ - DEFAULT_API_VERSION = '2023-07-01' + DEFAULT_API_VERSION = '2024-11-01' _PROFILE_TAG = "azure.mgmt.keyvault.KeyVaultManagementClient" LATEST_PROFILE = ProfileDefinition({ _PROFILE_TAG: { @@ -95,7 +95,7 @@ def __init__( policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, self._config.http_logging_policy, ] - self._client = AsyncARMPipelineClient(base_url=base_url, policies=_policies, **kwargs) + self._client: AsyncARMPipelineClient = AsyncARMPipelineClient(base_url=base_url, policies=_policies, **kwargs) super(KeyVaultManagementClient, self).__init__( api_version=api_version, profile=profile @@ -110,45 +110,17 @@ def models(cls, api_version=DEFAULT_API_VERSION): """Module depends on the API version: * 2016-10-01: :mod:`v2016_10_01.models` - * 2018-02-14: :mod:`v2018_02_14.models` - * 2019-09-01: :mod:`v2019_09_01.models` - * 2020-04-01-preview: :mod:`v2020_04_01_preview.models` - * 2021-04-01-preview: :mod:`v2021_04_01_preview.models` - * 2021-06-01-preview: :mod:`v2021_06_01_preview.models` - * 2021-10-01: :mod:`v2021_10_01.models` - * 2022-07-01: :mod:`v2022_07_01.models` * 2023-02-01: :mod:`v2023_02_01.models` - * 2023-07-01: :mod:`v2023_07_01.models` + * 2024-11-01: :mod:`v2024_11_01.models` """ if api_version == '2016-10-01': from ..v2016_10_01 import models return models - elif api_version == '2018-02-14': - from ..v2018_02_14 import models - return models - elif api_version == '2019-09-01': - from ..v2019_09_01 import models - return models - elif api_version == '2020-04-01-preview': - from ..v2020_04_01_preview import models - return models - elif api_version == '2021-04-01-preview': - from ..v2021_04_01_preview import models - return models - elif api_version == '2021-06-01-preview': - from ..v2021_06_01_preview import models - return models - elif api_version == '2021-10-01': - from ..v2021_10_01 import models - return models - elif api_version == '2022-07-01': - from ..v2022_07_01 import models - return models elif api_version == '2023-02-01': from ..v2023_02_01 import models return models - elif api_version == '2023-07-01': - from ..v2023_07_01 import models + elif api_version == '2024-11-01': + from ..v2024_11_01 import models return models raise ValueError("API version {} is not available".format(api_version)) @@ -156,29 +128,14 @@ def models(cls, api_version=DEFAULT_API_VERSION): def keys(self): """Instance depends on the API version: - * 2019-09-01: :class:`KeysOperations` - * 2020-04-01-preview: :class:`KeysOperations` - * 2021-06-01-preview: :class:`KeysOperations` - * 2021-10-01: :class:`KeysOperations` - * 2022-07-01: :class:`KeysOperations` * 2023-02-01: :class:`KeysOperations` - * 2023-07-01: :class:`KeysOperations` + * 2024-11-01: :class:`KeysOperations` """ api_version = self._get_api_version('keys') - if api_version == '2019-09-01': - from ..v2019_09_01.aio.operations import KeysOperations as OperationClass - elif api_version == '2020-04-01-preview': - from ..v2020_04_01_preview.aio.operations import KeysOperations as OperationClass - elif api_version == '2021-06-01-preview': - from ..v2021_06_01_preview.aio.operations import KeysOperations as OperationClass - elif api_version == '2021-10-01': - from ..v2021_10_01.aio.operations import KeysOperations as OperationClass - elif api_version == '2022-07-01': - from ..v2022_07_01.aio.operations import KeysOperations as OperationClass - elif api_version == '2023-02-01': + if api_version == '2023-02-01': from ..v2023_02_01.aio.operations import KeysOperations as OperationClass - elif api_version == '2023-07-01': - from ..v2023_07_01.aio.operations import KeysOperations as OperationClass + elif api_version == '2024-11-01': + from ..v2024_11_01.aio.operations import KeysOperations as OperationClass else: raise ValueError("API version {} does not have operation group 'keys'".format(api_version)) self._config.api_version = api_version @@ -189,13 +146,13 @@ def managed_hsm_keys(self): """Instance depends on the API version: * 2023-02-01: :class:`ManagedHsmKeysOperations` - * 2023-07-01: :class:`ManagedHsmKeysOperations` + * 2024-11-01: :class:`ManagedHsmKeysOperations` """ api_version = self._get_api_version('managed_hsm_keys') if api_version == '2023-02-01': from ..v2023_02_01.aio.operations import ManagedHsmKeysOperations as OperationClass - elif api_version == '2023-07-01': - from ..v2023_07_01.aio.operations import ManagedHsmKeysOperations as OperationClass + elif api_version == '2024-11-01': + from ..v2024_11_01.aio.operations import ManagedHsmKeysOperations as OperationClass else: raise ValueError("API version {} does not have operation group 'managed_hsm_keys'".format(api_version)) self._config.api_version = api_version @@ -205,29 +162,14 @@ def managed_hsm_keys(self): def managed_hsms(self): """Instance depends on the API version: - * 2020-04-01-preview: :class:`ManagedHsmsOperations` - * 2021-04-01-preview: :class:`ManagedHsmsOperations` - * 2021-06-01-preview: :class:`ManagedHsmsOperations` - * 2021-10-01: :class:`ManagedHsmsOperations` - * 2022-07-01: :class:`ManagedHsmsOperations` * 2023-02-01: :class:`ManagedHsmsOperations` - * 2023-07-01: :class:`ManagedHsmsOperations` + * 2024-11-01: :class:`ManagedHsmsOperations` """ api_version = self._get_api_version('managed_hsms') - if api_version == '2020-04-01-preview': - from ..v2020_04_01_preview.aio.operations import ManagedHsmsOperations as OperationClass - elif api_version == '2021-04-01-preview': - from ..v2021_04_01_preview.aio.operations import ManagedHsmsOperations as OperationClass - elif api_version == '2021-06-01-preview': - from ..v2021_06_01_preview.aio.operations import ManagedHsmsOperations as OperationClass - elif api_version == '2021-10-01': - from ..v2021_10_01.aio.operations import ManagedHsmsOperations as OperationClass - elif api_version == '2022-07-01': - from ..v2022_07_01.aio.operations import ManagedHsmsOperations as OperationClass - elif api_version == '2023-02-01': + if api_version == '2023-02-01': from ..v2023_02_01.aio.operations import ManagedHsmsOperations as OperationClass - elif api_version == '2023-07-01': - from ..v2023_07_01.aio.operations import ManagedHsmsOperations as OperationClass + elif api_version == '2024-11-01': + from ..v2024_11_01.aio.operations import ManagedHsmsOperations as OperationClass else: raise ValueError("API version {} does not have operation group 'managed_hsms'".format(api_version)) self._config.api_version = api_version @@ -237,26 +179,14 @@ def managed_hsms(self): def mhsm_private_endpoint_connections(self): """Instance depends on the API version: - * 2021-04-01-preview: :class:`MHSMPrivateEndpointConnectionsOperations` - * 2021-06-01-preview: :class:`MHSMPrivateEndpointConnectionsOperations` - * 2021-10-01: :class:`MHSMPrivateEndpointConnectionsOperations` - * 2022-07-01: :class:`MHSMPrivateEndpointConnectionsOperations` * 2023-02-01: :class:`MHSMPrivateEndpointConnectionsOperations` - * 2023-07-01: :class:`MHSMPrivateEndpointConnectionsOperations` + * 2024-11-01: :class:`MHSMPrivateEndpointConnectionsOperations` """ api_version = self._get_api_version('mhsm_private_endpoint_connections') - if api_version == '2021-04-01-preview': - from ..v2021_04_01_preview.aio.operations import MHSMPrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2021-06-01-preview': - from ..v2021_06_01_preview.aio.operations import MHSMPrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2021-10-01': - from ..v2021_10_01.aio.operations import MHSMPrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2022-07-01': - from ..v2022_07_01.aio.operations import MHSMPrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2023-02-01': + if api_version == '2023-02-01': from ..v2023_02_01.aio.operations import MHSMPrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2023-07-01': - from ..v2023_07_01.aio.operations import MHSMPrivateEndpointConnectionsOperations as OperationClass + elif api_version == '2024-11-01': + from ..v2024_11_01.aio.operations import MHSMPrivateEndpointConnectionsOperations as OperationClass else: raise ValueError("API version {} does not have operation group 'mhsm_private_endpoint_connections'".format(api_version)) self._config.api_version = api_version @@ -266,26 +196,14 @@ def mhsm_private_endpoint_connections(self): def mhsm_private_link_resources(self): """Instance depends on the API version: - * 2021-04-01-preview: :class:`MHSMPrivateLinkResourcesOperations` - * 2021-06-01-preview: :class:`MHSMPrivateLinkResourcesOperations` - * 2021-10-01: :class:`MHSMPrivateLinkResourcesOperations` - * 2022-07-01: :class:`MHSMPrivateLinkResourcesOperations` * 2023-02-01: :class:`MHSMPrivateLinkResourcesOperations` - * 2023-07-01: :class:`MHSMPrivateLinkResourcesOperations` + * 2024-11-01: :class:`MHSMPrivateLinkResourcesOperations` """ api_version = self._get_api_version('mhsm_private_link_resources') - if api_version == '2021-04-01-preview': - from ..v2021_04_01_preview.aio.operations import MHSMPrivateLinkResourcesOperations as OperationClass - elif api_version == '2021-06-01-preview': - from ..v2021_06_01_preview.aio.operations import MHSMPrivateLinkResourcesOperations as OperationClass - elif api_version == '2021-10-01': - from ..v2021_10_01.aio.operations import MHSMPrivateLinkResourcesOperations as OperationClass - elif api_version == '2022-07-01': - from ..v2022_07_01.aio.operations import MHSMPrivateLinkResourcesOperations as OperationClass - elif api_version == '2023-02-01': + if api_version == '2023-02-01': from ..v2023_02_01.aio.operations import MHSMPrivateLinkResourcesOperations as OperationClass - elif api_version == '2023-07-01': - from ..v2023_07_01.aio.operations import MHSMPrivateLinkResourcesOperations as OperationClass + elif api_version == '2024-11-01': + from ..v2024_11_01.aio.operations import MHSMPrivateLinkResourcesOperations as OperationClass else: raise ValueError("API version {} does not have operation group 'mhsm_private_link_resources'".format(api_version)) self._config.api_version = api_version @@ -296,13 +214,13 @@ def mhsm_regions(self): """Instance depends on the API version: * 2023-02-01: :class:`MHSMRegionsOperations` - * 2023-07-01: :class:`MHSMRegionsOperations` + * 2024-11-01: :class:`MHSMRegionsOperations` """ api_version = self._get_api_version('mhsm_regions') if api_version == '2023-02-01': from ..v2023_02_01.aio.operations import MHSMRegionsOperations as OperationClass - elif api_version == '2023-07-01': - from ..v2023_07_01.aio.operations import MHSMRegionsOperations as OperationClass + elif api_version == '2024-11-01': + from ..v2024_11_01.aio.operations import MHSMRegionsOperations as OperationClass else: raise ValueError("API version {} does not have operation group 'mhsm_regions'".format(api_version)) self._config.api_version = api_version @@ -313,37 +231,16 @@ def operations(self): """Instance depends on the API version: * 2016-10-01: :class:`Operations` - * 2018-02-14: :class:`Operations` - * 2019-09-01: :class:`Operations` - * 2020-04-01-preview: :class:`Operations` - * 2021-04-01-preview: :class:`Operations` - * 2021-06-01-preview: :class:`Operations` - * 2021-10-01: :class:`Operations` - * 2022-07-01: :class:`Operations` * 2023-02-01: :class:`Operations` - * 2023-07-01: :class:`Operations` + * 2024-11-01: :class:`Operations` """ api_version = self._get_api_version('operations') if api_version == '2016-10-01': from ..v2016_10_01.aio.operations import Operations as OperationClass - elif api_version == '2018-02-14': - from ..v2018_02_14.aio.operations import Operations as OperationClass - elif api_version == '2019-09-01': - from ..v2019_09_01.aio.operations import Operations as OperationClass - elif api_version == '2020-04-01-preview': - from ..v2020_04_01_preview.aio.operations import Operations as OperationClass - elif api_version == '2021-04-01-preview': - from ..v2021_04_01_preview.aio.operations import Operations as OperationClass - elif api_version == '2021-06-01-preview': - from ..v2021_06_01_preview.aio.operations import Operations as OperationClass - elif api_version == '2021-10-01': - from ..v2021_10_01.aio.operations import Operations as OperationClass - elif api_version == '2022-07-01': - from ..v2022_07_01.aio.operations import Operations as OperationClass elif api_version == '2023-02-01': from ..v2023_02_01.aio.operations import Operations as OperationClass - elif api_version == '2023-07-01': - from ..v2023_07_01.aio.operations import Operations as OperationClass + elif api_version == '2024-11-01': + from ..v2024_11_01.aio.operations import Operations as OperationClass else: raise ValueError("API version {} does not have operation group 'operations'".format(api_version)) self._config.api_version = api_version @@ -353,35 +250,14 @@ def operations(self): def private_endpoint_connections(self): """Instance depends on the API version: - * 2018-02-14: :class:`PrivateEndpointConnectionsOperations` - * 2019-09-01: :class:`PrivateEndpointConnectionsOperations` - * 2020-04-01-preview: :class:`PrivateEndpointConnectionsOperations` - * 2021-04-01-preview: :class:`PrivateEndpointConnectionsOperations` - * 2021-06-01-preview: :class:`PrivateEndpointConnectionsOperations` - * 2021-10-01: :class:`PrivateEndpointConnectionsOperations` - * 2022-07-01: :class:`PrivateEndpointConnectionsOperations` * 2023-02-01: :class:`PrivateEndpointConnectionsOperations` - * 2023-07-01: :class:`PrivateEndpointConnectionsOperations` + * 2024-11-01: :class:`PrivateEndpointConnectionsOperations` """ api_version = self._get_api_version('private_endpoint_connections') - if api_version == '2018-02-14': - from ..v2018_02_14.aio.operations import PrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2019-09-01': - from ..v2019_09_01.aio.operations import PrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2020-04-01-preview': - from ..v2020_04_01_preview.aio.operations import PrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2021-04-01-preview': - from ..v2021_04_01_preview.aio.operations import PrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2021-06-01-preview': - from ..v2021_06_01_preview.aio.operations import PrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2021-10-01': - from ..v2021_10_01.aio.operations import PrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2022-07-01': - from ..v2022_07_01.aio.operations import PrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2023-02-01': + if api_version == '2023-02-01': from ..v2023_02_01.aio.operations import PrivateEndpointConnectionsOperations as OperationClass - elif api_version == '2023-07-01': - from ..v2023_07_01.aio.operations import PrivateEndpointConnectionsOperations as OperationClass + elif api_version == '2024-11-01': + from ..v2024_11_01.aio.operations import PrivateEndpointConnectionsOperations as OperationClass else: raise ValueError("API version {} does not have operation group 'private_endpoint_connections'".format(api_version)) self._config.api_version = api_version @@ -391,35 +267,14 @@ def private_endpoint_connections(self): def private_link_resources(self): """Instance depends on the API version: - * 2018-02-14: :class:`PrivateLinkResourcesOperations` - * 2019-09-01: :class:`PrivateLinkResourcesOperations` - * 2020-04-01-preview: :class:`PrivateLinkResourcesOperations` - * 2021-04-01-preview: :class:`PrivateLinkResourcesOperations` - * 2021-06-01-preview: :class:`PrivateLinkResourcesOperations` - * 2021-10-01: :class:`PrivateLinkResourcesOperations` - * 2022-07-01: :class:`PrivateLinkResourcesOperations` * 2023-02-01: :class:`PrivateLinkResourcesOperations` - * 2023-07-01: :class:`PrivateLinkResourcesOperations` + * 2024-11-01: :class:`PrivateLinkResourcesOperations` """ api_version = self._get_api_version('private_link_resources') - if api_version == '2018-02-14': - from ..v2018_02_14.aio.operations import PrivateLinkResourcesOperations as OperationClass - elif api_version == '2019-09-01': - from ..v2019_09_01.aio.operations import PrivateLinkResourcesOperations as OperationClass - elif api_version == '2020-04-01-preview': - from ..v2020_04_01_preview.aio.operations import PrivateLinkResourcesOperations as OperationClass - elif api_version == '2021-04-01-preview': - from ..v2021_04_01_preview.aio.operations import PrivateLinkResourcesOperations as OperationClass - elif api_version == '2021-06-01-preview': - from ..v2021_06_01_preview.aio.operations import PrivateLinkResourcesOperations as OperationClass - elif api_version == '2021-10-01': - from ..v2021_10_01.aio.operations import PrivateLinkResourcesOperations as OperationClass - elif api_version == '2022-07-01': - from ..v2022_07_01.aio.operations import PrivateLinkResourcesOperations as OperationClass - elif api_version == '2023-02-01': + if api_version == '2023-02-01': from ..v2023_02_01.aio.operations import PrivateLinkResourcesOperations as OperationClass - elif api_version == '2023-07-01': - from ..v2023_07_01.aio.operations import PrivateLinkResourcesOperations as OperationClass + elif api_version == '2024-11-01': + from ..v2024_11_01.aio.operations import PrivateLinkResourcesOperations as OperationClass else: raise ValueError("API version {} does not have operation group 'private_link_resources'".format(api_version)) self._config.api_version = api_version @@ -429,26 +284,14 @@ def private_link_resources(self): def secrets(self): """Instance depends on the API version: - * 2020-04-01-preview: :class:`SecretsOperations` - * 2021-06-01-preview: :class:`SecretsOperations` - * 2021-10-01: :class:`SecretsOperations` - * 2022-07-01: :class:`SecretsOperations` * 2023-02-01: :class:`SecretsOperations` - * 2023-07-01: :class:`SecretsOperations` + * 2024-11-01: :class:`SecretsOperations` """ api_version = self._get_api_version('secrets') - if api_version == '2020-04-01-preview': - from ..v2020_04_01_preview.aio.operations import SecretsOperations as OperationClass - elif api_version == '2021-06-01-preview': - from ..v2021_06_01_preview.aio.operations import SecretsOperations as OperationClass - elif api_version == '2021-10-01': - from ..v2021_10_01.aio.operations import SecretsOperations as OperationClass - elif api_version == '2022-07-01': - from ..v2022_07_01.aio.operations import SecretsOperations as OperationClass - elif api_version == '2023-02-01': + if api_version == '2023-02-01': from ..v2023_02_01.aio.operations import SecretsOperations as OperationClass - elif api_version == '2023-07-01': - from ..v2023_07_01.aio.operations import SecretsOperations as OperationClass + elif api_version == '2024-11-01': + from ..v2024_11_01.aio.operations import SecretsOperations as OperationClass else: raise ValueError("API version {} does not have operation group 'secrets'".format(api_version)) self._config.api_version = api_version @@ -459,37 +302,16 @@ def vaults(self): """Instance depends on the API version: * 2016-10-01: :class:`VaultsOperations` - * 2018-02-14: :class:`VaultsOperations` - * 2019-09-01: :class:`VaultsOperations` - * 2020-04-01-preview: :class:`VaultsOperations` - * 2021-04-01-preview: :class:`VaultsOperations` - * 2021-06-01-preview: :class:`VaultsOperations` - * 2021-10-01: :class:`VaultsOperations` - * 2022-07-01: :class:`VaultsOperations` * 2023-02-01: :class:`VaultsOperations` - * 2023-07-01: :class:`VaultsOperations` + * 2024-11-01: :class:`VaultsOperations` """ api_version = self._get_api_version('vaults') if api_version == '2016-10-01': from ..v2016_10_01.aio.operations import VaultsOperations as OperationClass - elif api_version == '2018-02-14': - from ..v2018_02_14.aio.operations import VaultsOperations as OperationClass - elif api_version == '2019-09-01': - from ..v2019_09_01.aio.operations import VaultsOperations as OperationClass - elif api_version == '2020-04-01-preview': - from ..v2020_04_01_preview.aio.operations import VaultsOperations as OperationClass - elif api_version == '2021-04-01-preview': - from ..v2021_04_01_preview.aio.operations import VaultsOperations as OperationClass - elif api_version == '2021-06-01-preview': - from ..v2021_06_01_preview.aio.operations import VaultsOperations as OperationClass - elif api_version == '2021-10-01': - from ..v2021_10_01.aio.operations import VaultsOperations as OperationClass - elif api_version == '2022-07-01': - from ..v2022_07_01.aio.operations import VaultsOperations as OperationClass elif api_version == '2023-02-01': from ..v2023_02_01.aio.operations import VaultsOperations as OperationClass - elif api_version == '2023-07-01': - from ..v2023_07_01.aio.operations import VaultsOperations as OperationClass + elif api_version == '2024-11-01': + from ..v2024_11_01.aio.operations import VaultsOperations as OperationClass else: raise ValueError("API version {} does not have operation group 'vaults'".format(api_version)) self._config.api_version = api_version diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/models.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/models.py index bfb2c4939e8b..9571b83d434a 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/models.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/models.py @@ -4,4 +4,4 @@ # Licensed under the MIT License. See License.txt in the project root for # license information. # -------------------------------------------------------------------------- -from .v2023_07_01.models import * +from .v2024_11_01.models import * diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/__init__.py index 6bb4b7c63a45..a60631755701 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/__init__.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/__init__.py @@ -5,15 +5,21 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +# pylint: disable=wrong-import-position -from ._key_vault_management_client import KeyVaultManagementClient +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._key_vault_management_client import KeyVaultManagementClient # type: ignore from ._version import VERSION __version__ = VERSION try: from ._patch import __all__ as _patch_all - from ._patch import * # pylint: disable=unused-wildcard-import + from ._patch import * except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk @@ -21,6 +27,6 @@ __all__ = [ "KeyVaultManagementClient", ] -__all__.extend([p for p in _patch_all if p not in __all__]) +__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_configuration.py index 1321a318a4ae..07aaed1b979a 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_configuration.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_configuration.py @@ -14,11 +14,10 @@ from ._version import VERSION if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials import TokenCredential -class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long +class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes """Configuration for KeyVaultManagementClient. Note that all parameters used to create this instance are saved as instance diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_key_vault_management_client.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_key_vault_management_client.py index c992d41375db..cce3c6ca0cd1 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_key_vault_management_client.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_key_vault_management_client.py @@ -21,11 +21,10 @@ from .operations import Operations, VaultsOperations if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials import TokenCredential -class KeyVaultManagementClient: # pylint: disable=client-accepts-api-version-keyword +class KeyVaultManagementClient: """The Azure management API provides a RESTful set of web services that interact with Azure Key Vault. diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_version.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_version.py index 3b99a1418535..e5754a47ce68 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_version.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_version.py @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "10.3.1" +VERSION = "1.0.0b1" diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/__init__.py index 6ba0c5a05353..30acffb8c4a7 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/__init__.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/__init__.py @@ -5,12 +5,18 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +# pylint: disable=wrong-import-position -from ._key_vault_management_client import KeyVaultManagementClient +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._key_vault_management_client import KeyVaultManagementClient # type: ignore try: from ._patch import __all__ as _patch_all - from ._patch import * # pylint: disable=unused-wildcard-import + from ._patch import * except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk @@ -18,6 +24,6 @@ __all__ = [ "KeyVaultManagementClient", ] -__all__.extend([p for p in _patch_all if p not in __all__]) +__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/_configuration.py index 731e354e718b..27f8c949be48 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/_configuration.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/_configuration.py @@ -14,11 +14,10 @@ from .._version import VERSION if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials_async import AsyncTokenCredential -class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long +class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes """Configuration for KeyVaultManagementClient. Note that all parameters used to create this instance are saved as instance diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/_key_vault_management_client.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/_key_vault_management_client.py index 7c3aa2e658a3..ab19a5f0e773 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/_key_vault_management_client.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/_key_vault_management_client.py @@ -21,11 +21,10 @@ from .operations import Operations, VaultsOperations if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials_async import AsyncTokenCredential -class KeyVaultManagementClient: # pylint: disable=client-accepts-api-version-keyword +class KeyVaultManagementClient: """The Azure management API provides a RESTful set of web services that interact with Azure Key Vault. diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/operations/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/operations/__init__.py index 34a990d46881..7c6c816c2cda 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/operations/__init__.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/operations/__init__.py @@ -5,17 +5,23 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +# pylint: disable=wrong-import-position -from ._vaults_operations import VaultsOperations -from ._operations import Operations +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._vaults_operations import VaultsOperations # type: ignore +from ._operations import Operations # type: ignore from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import +from ._patch import * from ._patch import patch_sdk as _patch_sdk __all__ = [ "VaultsOperations", "Operations", ] -__all__.extend([p for p in _patch_all if p not in __all__]) +__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/operations/_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/operations/_operations.py index a01ecd78ae0c..319b67116970 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/operations/_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/operations/_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,7 +6,7 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import sys -from typing import Any, AsyncIterable, Callable, Dict, Optional, Type, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList @@ -31,7 +30,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -71,7 +70,7 @@ def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2016-10-01")) cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/operations/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/operations/_patch.py index 9b4f32f151b7..a22e2c723f41 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/operations/_patch.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/operations/_patch.py @@ -38,6 +38,7 @@ else: from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + class VaultsOperations(_VaultsOperations): @distributed_trace @@ -57,9 +58,7 @@ def list(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_mode filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", "2015-11-01") - ) + api_version: Literal["2015-11-01"] = kwargs.pop("api_version", _params.pop("api-version", "2015-11-01")) cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) error_map: MutableMapping[int, Type[HttpResponseError]] = { @@ -124,6 +123,7 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) + __all__: List[str] = ["VaultsOperations"] # Add all objects you want publicly available to users at this package level diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/operations/_vaults_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/operations/_vaults_operations.py index b70b55fb66b3..039560033b6c 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/operations/_vaults_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/operations/_vaults_operations.py @@ -1,4 +1,4 @@ -# pylint: disable=too-many-lines,too-many-statements +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -17,7 +17,6 @@ IO, Literal, Optional, - Type, TypeVar, Union, cast, @@ -32,6 +31,8 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.pipeline import PipelineResponse @@ -62,7 +63,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -164,7 +165,7 @@ async def create_or_update( :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.Vault :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -211,11 +212,7 @@ async def create_or_update( map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Vault", pipeline_response.http_response) + deserialized = self._deserialize("Vault", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -298,7 +295,7 @@ async def update( :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.Vault :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -345,11 +342,7 @@ async def update( map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Vault", pipeline_response.http_response) + deserialized = self._deserialize("Vault", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -357,9 +350,7 @@ async def update( return deserialized # type: ignore @distributed_trace_async - async def delete( # pylint: disable=inconsistent-return-statements - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> None: + async def delete(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> None: """Deletes the specified Azure key vault. :param resource_group_name: The name of the Resource Group to which the vault belongs. @@ -371,7 +362,7 @@ async def delete( # pylint: disable=inconsistent-return-statements :rtype: None :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -422,7 +413,7 @@ async def get(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.Vault :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -553,7 +544,7 @@ async def update_access_policy( :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.VaultAccessPolicyParameters :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -601,11 +592,7 @@ async def update_access_policy( map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -634,7 +621,7 @@ def list_by_resource_group( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2016-10-01")) cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -712,7 +699,7 @@ def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> Asyn api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2016-10-01")) cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -788,7 +775,7 @@ def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedVault"]: api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2016-10-01")) cls: ClsType[_models.DeletedVaultListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -860,7 +847,7 @@ async def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _m :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.DeletedVault :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -903,7 +890,7 @@ async def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _m return deserialized # type: ignore async def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -927,6 +914,7 @@ async def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -935,15 +923,14 @@ async def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: response = pipeline_response.http_response if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -1024,7 +1011,7 @@ def list(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_mode ) cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1136,7 +1123,7 @@ async def check_name_availability( :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.CheckNameAvailabilityResult :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/models/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/models/__init__.py index b5ca82e4f2f1..e66a4a07a7b3 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/models/__init__.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/models/__init__.py @@ -5,42 +5,53 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +# pylint: disable=wrong-import-position -from ._models_py3 import AccessPolicyEntry -from ._models_py3 import CheckNameAvailabilityResult -from ._models_py3 import DeletedVault -from ._models_py3 import DeletedVaultListResult -from ._models_py3 import DeletedVaultProperties -from ._models_py3 import LogSpecification -from ._models_py3 import Operation -from ._models_py3 import OperationDisplay -from ._models_py3 import OperationListResult -from ._models_py3 import Permissions -from ._models_py3 import Resource -from ._models_py3 import ResourceListResult -from ._models_py3 import ServiceSpecification -from ._models_py3 import Sku -from ._models_py3 import Vault -from ._models_py3 import VaultAccessPolicyParameters -from ._models_py3 import VaultAccessPolicyProperties -from ._models_py3 import VaultCheckNameAvailabilityParameters -from ._models_py3 import VaultCreateOrUpdateParameters -from ._models_py3 import VaultListResult -from ._models_py3 import VaultPatchParameters -from ._models_py3 import VaultPatchProperties -from ._models_py3 import VaultProperties +from typing import TYPE_CHECKING -from ._key_vault_management_client_enums import AccessPolicyUpdateKind -from ._key_vault_management_client_enums import CertificatePermissions -from ._key_vault_management_client_enums import CreateMode -from ._key_vault_management_client_enums import KeyPermissions -from ._key_vault_management_client_enums import Reason -from ._key_vault_management_client_enums import SecretPermissions -from ._key_vault_management_client_enums import SkuFamily -from ._key_vault_management_client_enums import SkuName -from ._key_vault_management_client_enums import StoragePermissions +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + + +from ._models_py3 import ( # type: ignore + AccessPolicyEntry, + CheckNameAvailabilityResult, + DeletedVault, + DeletedVaultListResult, + DeletedVaultProperties, + LogSpecification, + Operation, + OperationDisplay, + OperationListResult, + Permissions, + Resource, + ResourceListResult, + ServiceSpecification, + Sku, + Vault, + VaultAccessPolicyParameters, + VaultAccessPolicyProperties, + VaultCheckNameAvailabilityParameters, + VaultCreateOrUpdateParameters, + VaultListResult, + VaultPatchParameters, + VaultPatchProperties, + VaultProperties, +) + +from ._key_vault_management_client_enums import ( # type: ignore + AccessPolicyUpdateKind, + CertificatePermissions, + CreateMode, + KeyPermissions, + Reason, + SecretPermissions, + SkuFamily, + SkuName, + StoragePermissions, +) from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import +from ._patch import * from ._patch import patch_sdk as _patch_sdk __all__ = [ @@ -77,5 +88,5 @@ "SkuName", "StoragePermissions", ] -__all__.extend([p for p in _patch_all if p not in __all__]) +__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/models/_models_py3.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/models/_models_py3.py index 1eac911264b8..8147abc97882 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/models/_models_py3.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/models/_models_py3.py @@ -1,5 +1,5 @@ -# coding=utf-8 # pylint: disable=too-many-lines +# coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. @@ -12,7 +12,6 @@ from ... import _serialization if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from .. import models as _models diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/operations/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/operations/__init__.py index 34a990d46881..7c6c816c2cda 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/operations/__init__.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/operations/__init__.py @@ -5,17 +5,23 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +# pylint: disable=wrong-import-position -from ._vaults_operations import VaultsOperations -from ._operations import Operations +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._vaults_operations import VaultsOperations # type: ignore +from ._operations import Operations # type: ignore from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import +from ._patch import * from ._patch import patch_sdk as _patch_sdk __all__ = [ "VaultsOperations", "Operations", ] -__all__.extend([p for p in _patch_all if p not in __all__]) +__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/operations/_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/operations/_operations.py index 6ef1fd4eae18..27629e5f8b09 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/operations/_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/operations/_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,7 +6,7 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import sys -from typing import Any, Callable, Dict, Iterable, Optional, Type, TypeVar +from typing import Any, Callable, Dict, Iterable, Optional, TypeVar import urllib.parse from azure.core.exceptions import ( @@ -31,7 +30,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -92,7 +91,7 @@ def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2016-10-01")) cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/operations/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/operations/_patch.py index d6256c7691f8..334f35c7eee1 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/operations/_patch.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/operations/_patch.py @@ -37,6 +37,7 @@ else: from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + class VaultsOperations(_VaultsOperations): @distributed_trace def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Resource"]: @@ -54,9 +55,7 @@ def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Re filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", "2015-11-01") - ) + api_version: Literal["2015-11-01"] = kwargs.pop("api_version", _params.pop("api-version", "2015-11-01")) cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) error_map: MutableMapping[int, Type[HttpResponseError]] = { diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/operations/_vaults_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/operations/_vaults_operations.py index f4e5081651d4..3962d539183d 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/operations/_vaults_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/operations/_vaults_operations.py @@ -1,4 +1,4 @@ -# pylint: disable=too-many-lines,too-many-statements +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +8,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Literal, Optional, Type, TypeVar, Union, cast, overload +from typing import Any, Callable, Dict, IO, Iterable, Iterator, Literal, Optional, TypeVar, Union, cast, overload import urllib.parse from azure.core.exceptions import ( @@ -17,6 +17,8 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.paging import ItemPaged @@ -34,7 +36,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -491,7 +493,7 @@ def create_or_update( :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.Vault :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -538,11 +540,7 @@ def create_or_update( map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Vault", pipeline_response.http_response) + deserialized = self._deserialize("Vault", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -625,7 +623,7 @@ def update( :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.Vault :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -672,11 +670,7 @@ def update( map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Vault", pipeline_response.http_response) + deserialized = self._deserialize("Vault", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -698,7 +692,7 @@ def delete( # pylint: disable=inconsistent-return-statements :rtype: None :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -749,7 +743,7 @@ def get(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> _mode :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.Vault :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -880,7 +874,7 @@ def update_access_policy( :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.VaultAccessPolicyParameters :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -928,11 +922,7 @@ def update_access_policy( map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -961,7 +951,7 @@ def list_by_resource_group( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2016-10-01")) cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1039,7 +1029,7 @@ def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> Iter api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2016-10-01")) cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1114,7 +1104,7 @@ def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedVault"]: api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2016-10-01")) cls: ClsType[_models.DeletedVaultListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1186,7 +1176,7 @@ def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _models. :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.DeletedVault :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1229,7 +1219,7 @@ def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _models. return deserialized # type: ignore def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1253,6 +1243,7 @@ def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -1261,15 +1252,14 @@ def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) response = pipeline_response.http_response if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -1349,7 +1339,7 @@ def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Re ) cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1461,7 +1451,7 @@ def check_name_availability( :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.CheckNameAvailabilityResult :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/_configuration.py deleted file mode 100644 index 2ef15d16eb57..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/_configuration.py +++ /dev/null @@ -1,66 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from typing import Any, TYPE_CHECKING - -from azure.core.pipeline import policies -from azure.mgmt.core.policies import ARMChallengeAuthenticationPolicy, ARMHttpLoggingPolicy - -from ._version import VERSION - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials import TokenCredential - - -class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long - """Configuration for KeyVaultManagementClient. - - Note that all parameters used to create this instance are saved as instance - attributes. - - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials.TokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :keyword api_version: Api Version. Default value is "2018-02-14". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str - """ - - def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None: - api_version: str = kwargs.pop("api_version", "2018-02-14") - - if credential is None: - raise ValueError("Parameter 'credential' must not be None.") - if subscription_id is None: - raise ValueError("Parameter 'subscription_id' must not be None.") - - self.credential = credential - self.subscription_id = subscription_id - self.api_version = api_version - self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) - kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) - self.polling_interval = kwargs.get("polling_interval", 30) - self._configure(**kwargs) - - def _configure(self, **kwargs: Any) -> None: - 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.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**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) - self.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs) - self.authentication_policy = kwargs.get("authentication_policy") - if self.credential and not self.authentication_policy: - self.authentication_policy = ARMChallengeAuthenticationPolicy( - self.credential, *self.credential_scopes, **kwargs - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/_key_vault_management_client.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/_key_vault_management_client.py deleted file mode 100644 index a19e272f1cbc..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/_key_vault_management_client.py +++ /dev/null @@ -1,134 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from copy import deepcopy -from typing import Any, TYPE_CHECKING -from typing_extensions import Self - -from azure.core.pipeline import policies -from azure.core.rest import HttpRequest, HttpResponse -from azure.mgmt.core import ARMPipelineClient -from azure.mgmt.core.policies import ARMAutoResourceProviderRegistrationPolicy - -from . import models as _models -from .._serialization import Deserializer, Serializer -from ._configuration import KeyVaultManagementClientConfiguration -from .operations import ( - Operations, - PrivateEndpointConnectionsOperations, - PrivateLinkResourcesOperations, - VaultsOperations, -) - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials import TokenCredential - - -class KeyVaultManagementClient: # pylint: disable=client-accepts-api-version-keyword - """The Azure management API provides a RESTful set of web services that interact with Azure Key - Vault. - - :ivar vaults: VaultsOperations operations - :vartype vaults: azure.mgmt.keyvault.v2018_02_14.operations.VaultsOperations - :ivar private_endpoint_connections: PrivateEndpointConnectionsOperations operations - :vartype private_endpoint_connections: - azure.mgmt.keyvault.v2018_02_14.operations.PrivateEndpointConnectionsOperations - :ivar private_link_resources: PrivateLinkResourcesOperations operations - :vartype private_link_resources: - azure.mgmt.keyvault.v2018_02_14.operations.PrivateLinkResourcesOperations - :ivar operations: Operations operations - :vartype operations: azure.mgmt.keyvault.v2018_02_14.operations.Operations - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials.TokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :param base_url: Service URL. Default value is "https://management.azure.com". - :type base_url: str - :keyword api_version: Api Version. Default value is "2018-02-14". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. - """ - - def __init__( - self, - credential: "TokenCredential", - subscription_id: str, - base_url: str = "https://management.azure.com", - **kwargs: Any - ) -> None: - self._config = KeyVaultManagementClientConfiguration( - credential=credential, subscription_id=subscription_id, **kwargs - ) - _policies = kwargs.pop("policies", None) - if _policies is None: - _policies = [ - policies.RequestIdPolicy(**kwargs), - self._config.headers_policy, - self._config.user_agent_policy, - self._config.proxy_policy, - policies.ContentDecodePolicy(**kwargs), - ARMAutoResourceProviderRegistrationPolicy(), - self._config.redirect_policy, - self._config.retry_policy, - self._config.authentication_policy, - self._config.custom_hook_policy, - self._config.logging_policy, - policies.DistributedTracingPolicy(**kwargs), - policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, - self._config.http_logging_policy, - ] - self._client: ARMPipelineClient = ARMPipelineClient(base_url=base_url, policies=_policies, **kwargs) - - client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} - self._serialize = Serializer(client_models) - self._deserialize = Deserializer(client_models) - self._serialize.client_side_validation = False - self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize, "2018-02-14") - self.private_endpoint_connections = PrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2018-02-14" - ) - self.private_link_resources = PrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2018-02-14" - ) - self.operations = Operations(self._client, self._config, self._serialize, self._deserialize, "2018-02-14") - - def _send_request(self, request: HttpRequest, *, stream: bool = False, **kwargs: Any) -> HttpResponse: - """Runs the network request through the client's chained policies. - - >>> from azure.core.rest import HttpRequest - >>> request = HttpRequest("GET", "https://www.example.org/") - - >>> response = client._send_request(request) - - - For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request - - :param request: The network request you want to make. Required. - :type request: ~azure.core.rest.HttpRequest - :keyword bool stream: Whether the response payload will be streamed. Defaults to False. - :return: The response of your network call. Does not do error handling on your response. - :rtype: ~azure.core.rest.HttpResponse - """ - - request_copy = deepcopy(request) - request_copy.url = self._client.format_url(request_copy.url) - return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore - - def close(self) -> None: - self._client.close() - - def __enter__(self) -> Self: - self._client.__enter__() - return self - - def __exit__(self, *exc_details: Any) -> None: - self._client.__exit__(*exc_details) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/_metadata.json b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/_metadata.json deleted file mode 100644 index 46c100187a6c..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/_metadata.json +++ /dev/null @@ -1,113 +0,0 @@ -{ - "chosen_version": "2018-02-14", - "total_api_version_list": ["2018-02-14"], - "client": { - "name": "KeyVaultManagementClient", - "filename": "_key_vault_management_client", - "description": "The Azure management API provides a RESTful set of web services that interact with Azure Key Vault.", - "host_value": "\"https://management.azure.com\"", - "parameterized_host_template": null, - "azure_arm": true, - "has_public_lro_operations": true, - "client_side_validation": false, - "sync_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"sdkcore\": {\"azure.mgmt.core\": [\"ARMPipelineClient\"], \"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"ARMAutoResourceProviderRegistrationPolicy\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \".._serialization\": [\"Deserializer\", \"Serializer\"]}, \"stdlib\": {\"typing_extensions\": [\"Self\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}}", - "async_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"sdkcore\": {\"azure.mgmt.core\": [\"AsyncARMPipelineClient\"], \"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"AsyncARMAutoResourceProviderRegistrationPolicy\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \"..._serialization\": [\"Deserializer\", \"Serializer\"]}, \"stdlib\": {\"typing_extensions\": [\"Self\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"]}}}" - }, - "global_parameters": { - "sync": { - "credential": { - "signature": "credential: \"TokenCredential\",", - "description": "Credential needed for the client to connect to Azure. Required.", - "docstring_type": "~azure.core.credentials.TokenCredential", - "required": true, - "method_location": "positional" - }, - "subscription_id": { - "signature": "subscription_id: str,", - "description": "Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. Required.", - "docstring_type": "str", - "required": true, - "method_location": "positional" - } - }, - "async": { - "credential": { - "signature": "credential: \"AsyncTokenCredential\",", - "description": "Credential needed for the client to connect to Azure. Required.", - "docstring_type": "~azure.core.credentials_async.AsyncTokenCredential", - "required": true - }, - "subscription_id": { - "signature": "subscription_id: str,", - "description": "Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. Required.", - "docstring_type": "str", - "required": true - } - }, - "constant": { - }, - "call": "credential, subscription_id", - "service_client_specific": { - "sync": { - "api_version": { - "signature": "api_version: Optional[str]=None,", - "description": "API version to use if no profile is provided, or if missing in profile.", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "base_url": { - "signature": "base_url: str = \"https://management.azure.com\",", - "description": "Service URL", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "profile": { - "signature": "profile: KnownProfiles=KnownProfiles.default,", - "description": "A profile definition, from KnownProfiles to dict.", - "docstring_type": "azure.profiles.KnownProfiles", - "required": false, - "method_location": "positional" - } - }, - "async": { - "api_version": { - "signature": "api_version: Optional[str] = None,", - "description": "API version to use if no profile is provided, or if missing in profile.", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "base_url": { - "signature": "base_url: str = \"https://management.azure.com\",", - "description": "Service URL", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "profile": { - "signature": "profile: KnownProfiles = KnownProfiles.default,", - "description": "A profile definition, from KnownProfiles to dict.", - "docstring_type": "azure.profiles.KnownProfiles", - "required": false, - "method_location": "positional" - } - } - } - }, - "config": { - "credential": true, - "credential_scopes": ["https://management.azure.com/.default"], - "credential_call_sync": "ARMChallengeAuthenticationPolicy(self.credential, *self.credential_scopes, **kwargs)", - "credential_call_async": "AsyncARMChallengeAuthenticationPolicy(self.credential, *self.credential_scopes, **kwargs)", - "sync_imports": "{\"regular\": {\"sdkcore\": {\"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"ARMChallengeAuthenticationPolicy\", \"ARMHttpLoggingPolicy\"]}, \"local\": {\"._version\": [\"VERSION\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}}", - "async_imports": "{\"regular\": {\"sdkcore\": {\"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"ARMHttpLoggingPolicy\", \"AsyncARMChallengeAuthenticationPolicy\"]}, \"local\": {\".._version\": [\"VERSION\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"]}}}" - }, - "operation_groups": { - "vaults": "VaultsOperations", - "private_endpoint_connections": "PrivateEndpointConnectionsOperations", - "private_link_resources": "PrivateLinkResourcesOperations", - "operations": "Operations" - } -} diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/_version.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/_version.py deleted file mode 100644 index 3b99a1418535..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/_version.py +++ /dev/null @@ -1,9 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -VERSION = "10.3.1" diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/__init__.py deleted file mode 100644 index 6ba0c5a05353..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/__init__.py +++ /dev/null @@ -1,23 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._key_vault_management_client import KeyVaultManagementClient - -try: - from ._patch import __all__ as _patch_all - from ._patch import * # pylint: disable=unused-wildcard-import -except ImportError: - _patch_all = [] -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "KeyVaultManagementClient", -] -__all__.extend([p for p in _patch_all if p not in __all__]) - -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/_configuration.py deleted file mode 100644 index b2cc1057bf38..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/_configuration.py +++ /dev/null @@ -1,66 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from typing import Any, TYPE_CHECKING - -from azure.core.pipeline import policies -from azure.mgmt.core.policies import ARMHttpLoggingPolicy, AsyncARMChallengeAuthenticationPolicy - -from .._version import VERSION - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials_async import AsyncTokenCredential - - -class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long - """Configuration for KeyVaultManagementClient. - - Note that all parameters used to create this instance are saved as instance - attributes. - - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials_async.AsyncTokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :keyword api_version: Api Version. Default value is "2018-02-14". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str - """ - - def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None: - api_version: str = kwargs.pop("api_version", "2018-02-14") - - if credential is None: - raise ValueError("Parameter 'credential' must not be None.") - if subscription_id is None: - raise ValueError("Parameter 'subscription_id' must not be None.") - - self.credential = credential - self.subscription_id = subscription_id - self.api_version = api_version - self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) - kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) - self.polling_interval = kwargs.get("polling_interval", 30) - self._configure(**kwargs) - - def _configure(self, **kwargs: Any) -> None: - 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.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**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) - self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) - self.authentication_policy = kwargs.get("authentication_policy") - if self.credential and not self.authentication_policy: - self.authentication_policy = AsyncARMChallengeAuthenticationPolicy( - self.credential, *self.credential_scopes, **kwargs - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/_key_vault_management_client.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/_key_vault_management_client.py deleted file mode 100644 index ca0ddc6d90d9..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/_key_vault_management_client.py +++ /dev/null @@ -1,136 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from copy import deepcopy -from typing import Any, Awaitable, TYPE_CHECKING -from typing_extensions import Self - -from azure.core.pipeline import policies -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.mgmt.core import AsyncARMPipelineClient -from azure.mgmt.core.policies import AsyncARMAutoResourceProviderRegistrationPolicy - -from .. import models as _models -from ..._serialization import Deserializer, Serializer -from ._configuration import KeyVaultManagementClientConfiguration -from .operations import ( - Operations, - PrivateEndpointConnectionsOperations, - PrivateLinkResourcesOperations, - VaultsOperations, -) - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials_async import AsyncTokenCredential - - -class KeyVaultManagementClient: # pylint: disable=client-accepts-api-version-keyword - """The Azure management API provides a RESTful set of web services that interact with Azure Key - Vault. - - :ivar vaults: VaultsOperations operations - :vartype vaults: azure.mgmt.keyvault.v2018_02_14.aio.operations.VaultsOperations - :ivar private_endpoint_connections: PrivateEndpointConnectionsOperations operations - :vartype private_endpoint_connections: - azure.mgmt.keyvault.v2018_02_14.aio.operations.PrivateEndpointConnectionsOperations - :ivar private_link_resources: PrivateLinkResourcesOperations operations - :vartype private_link_resources: - azure.mgmt.keyvault.v2018_02_14.aio.operations.PrivateLinkResourcesOperations - :ivar operations: Operations operations - :vartype operations: azure.mgmt.keyvault.v2018_02_14.aio.operations.Operations - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials_async.AsyncTokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :param base_url: Service URL. Default value is "https://management.azure.com". - :type base_url: str - :keyword api_version: Api Version. Default value is "2018-02-14". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. - """ - - def __init__( - self, - credential: "AsyncTokenCredential", - subscription_id: str, - base_url: str = "https://management.azure.com", - **kwargs: Any - ) -> None: - self._config = KeyVaultManagementClientConfiguration( - credential=credential, subscription_id=subscription_id, **kwargs - ) - _policies = kwargs.pop("policies", None) - if _policies is None: - _policies = [ - policies.RequestIdPolicy(**kwargs), - self._config.headers_policy, - self._config.user_agent_policy, - self._config.proxy_policy, - policies.ContentDecodePolicy(**kwargs), - AsyncARMAutoResourceProviderRegistrationPolicy(), - self._config.redirect_policy, - self._config.retry_policy, - self._config.authentication_policy, - self._config.custom_hook_policy, - self._config.logging_policy, - policies.DistributedTracingPolicy(**kwargs), - policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, - self._config.http_logging_policy, - ] - self._client: AsyncARMPipelineClient = AsyncARMPipelineClient(base_url=base_url, policies=_policies, **kwargs) - - client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} - self._serialize = Serializer(client_models) - self._deserialize = Deserializer(client_models) - self._serialize.client_side_validation = False - self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize, "2018-02-14") - self.private_endpoint_connections = PrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2018-02-14" - ) - self.private_link_resources = PrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2018-02-14" - ) - self.operations = Operations(self._client, self._config, self._serialize, self._deserialize, "2018-02-14") - - def _send_request( - self, request: HttpRequest, *, stream: bool = False, **kwargs: Any - ) -> Awaitable[AsyncHttpResponse]: - """Runs the network request through the client's chained policies. - - >>> from azure.core.rest import HttpRequest - >>> request = HttpRequest("GET", "https://www.example.org/") - - >>> response = await client._send_request(request) - - - For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request - - :param request: The network request you want to make. Required. - :type request: ~azure.core.rest.HttpRequest - :keyword bool stream: Whether the response payload will be streamed. Defaults to False. - :return: The response of your network call. Does not do error handling on your response. - :rtype: ~azure.core.rest.AsyncHttpResponse - """ - - request_copy = deepcopy(request) - request_copy.url = self._client.format_url(request_copy.url) - return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore - - async def close(self) -> None: - await self._client.close() - - async def __aenter__(self) -> Self: - await self._client.__aenter__() - return self - - async def __aexit__(self, *exc_details: Any) -> None: - await self._client.__aexit__(*exc_details) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/operations/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/operations/__init__.py deleted file mode 100644 index cab449d09e5b..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/operations/__init__.py +++ /dev/null @@ -1,25 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._vaults_operations import VaultsOperations -from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations -from ._private_link_resources_operations import PrivateLinkResourcesOperations -from ._operations import Operations - -from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "VaultsOperations", - "PrivateEndpointConnectionsOperations", - "PrivateLinkResourcesOperations", - "Operations", -] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/operations/_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/operations/_operations.py deleted file mode 100644 index 71dd672b281d..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/operations/_operations.py +++ /dev/null @@ -1,131 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, AsyncIterable, Callable, Dict, Optional, Type, TypeVar -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._operations import build_list_request - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class Operations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2018_02_14.aio.KeyVaultManagementClient`'s - :attr:`operations` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: - """Lists all of the available Key Vault Rest API operations. - - :return: An iterator like instance of either Operation or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2018_02_14.models.Operation] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("OperationListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/operations/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/operations/_patch.py deleted file mode 100644 index 9b4f32f151b7..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/operations/_patch.py +++ /dev/null @@ -1,136 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -import sys -from typing import AsyncIterable, Any, Optional, List, Type -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ._vaults_operations import VaultsOperations as _VaultsOperations, ClsType -from ...operations._vaults_operations import build_list_request - -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports - -class VaultsOperations(_VaultsOperations): - - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - -__all__: List[str] = ["VaultsOperations"] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/operations/_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/operations/_private_endpoint_connections_operations.py deleted file mode 100644 index 79670fbb3790..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/operations/_private_endpoint_connections_operations.py +++ /dev/null @@ -1,391 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterator, Callable, Dict, IO, Optional, Type, TypeVar, Union, cast, overload - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._private_endpoint_connections_operations import ( - build_delete_request, - build_get_request, - build_put_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class PrivateEndpointConnectionsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2018_02_14.aio.KeyVaultManagementClient`'s - :attr:`private_endpoint_connections` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace_async - async def get( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Gets the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: _models.PrivateEndpointConnection, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: Union[_models.PrivateEndpointConnection, IO[bytes]], - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Is either a - PrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection or - IO[bytes] - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _json = self._serialize.body(properties, "PrivateEndpointConnection") - - _request = build_put_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Azure-AsyncOperation"] = self._deserialize( - "str", response.headers.get("Azure-AsyncOperation") - ) - - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - async def _delete_initial( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_delete( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> AsyncLROPoller[_models.PrivateEndpointConnection]: - """Deletes the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: An instance of AsyncLROPoller that returns either PrivateEndpointConnection or the - result of cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._delete_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.PrivateEndpointConnection].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.PrivateEndpointConnection]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/models/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/models/__init__.py deleted file mode 100644 index 16908785dba6..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/models/__init__.py +++ /dev/null @@ -1,109 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._models_py3 import AccessPolicyEntry -from ._models_py3 import CheckNameAvailabilityResult -from ._models_py3 import CloudErrorBody -from ._models_py3 import DeletedVault -from ._models_py3 import DeletedVaultListResult -from ._models_py3 import DeletedVaultProperties -from ._models_py3 import IPRule -from ._models_py3 import LogSpecification -from ._models_py3 import NetworkRuleSet -from ._models_py3 import Operation -from ._models_py3 import OperationDisplay -from ._models_py3 import OperationListResult -from ._models_py3 import Permissions -from ._models_py3 import PrivateEndpoint -from ._models_py3 import PrivateEndpointConnection -from ._models_py3 import PrivateEndpointConnectionItem -from ._models_py3 import PrivateLinkResource -from ._models_py3 import PrivateLinkResourceListResult -from ._models_py3 import PrivateLinkServiceConnectionState -from ._models_py3 import Resource -from ._models_py3 import ResourceListResult -from ._models_py3 import ServiceSpecification -from ._models_py3 import Sku -from ._models_py3 import Vault -from ._models_py3 import VaultAccessPolicyParameters -from ._models_py3 import VaultAccessPolicyProperties -from ._models_py3 import VaultCheckNameAvailabilityParameters -from ._models_py3 import VaultCreateOrUpdateParameters -from ._models_py3 import VaultListResult -from ._models_py3 import VaultPatchParameters -from ._models_py3 import VaultPatchProperties -from ._models_py3 import VaultProperties -from ._models_py3 import VirtualNetworkRule - -from ._key_vault_management_client_enums import AccessPolicyUpdateKind -from ._key_vault_management_client_enums import CertificatePermissions -from ._key_vault_management_client_enums import CreateMode -from ._key_vault_management_client_enums import KeyPermissions -from ._key_vault_management_client_enums import NetworkRuleAction -from ._key_vault_management_client_enums import NetworkRuleBypassOptions -from ._key_vault_management_client_enums import PrivateEndpointConnectionProvisioningState -from ._key_vault_management_client_enums import PrivateEndpointServiceConnectionStatus -from ._key_vault_management_client_enums import Reason -from ._key_vault_management_client_enums import SecretPermissions -from ._key_vault_management_client_enums import SkuFamily -from ._key_vault_management_client_enums import SkuName -from ._key_vault_management_client_enums import StoragePermissions -from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "AccessPolicyEntry", - "CheckNameAvailabilityResult", - "CloudErrorBody", - "DeletedVault", - "DeletedVaultListResult", - "DeletedVaultProperties", - "IPRule", - "LogSpecification", - "NetworkRuleSet", - "Operation", - "OperationDisplay", - "OperationListResult", - "Permissions", - "PrivateEndpoint", - "PrivateEndpointConnection", - "PrivateEndpointConnectionItem", - "PrivateLinkResource", - "PrivateLinkResourceListResult", - "PrivateLinkServiceConnectionState", - "Resource", - "ResourceListResult", - "ServiceSpecification", - "Sku", - "Vault", - "VaultAccessPolicyParameters", - "VaultAccessPolicyProperties", - "VaultCheckNameAvailabilityParameters", - "VaultCreateOrUpdateParameters", - "VaultListResult", - "VaultPatchParameters", - "VaultPatchProperties", - "VaultProperties", - "VirtualNetworkRule", - "AccessPolicyUpdateKind", - "CertificatePermissions", - "CreateMode", - "KeyPermissions", - "NetworkRuleAction", - "NetworkRuleBypassOptions", - "PrivateEndpointConnectionProvisioningState", - "PrivateEndpointServiceConnectionStatus", - "Reason", - "SecretPermissions", - "SkuFamily", - "SkuName", - "StoragePermissions", -] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/models/_key_vault_management_client_enums.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/models/_key_vault_management_client_enums.py deleted file mode 100644 index b83265e6ea72..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/models/_key_vault_management_client_enums.py +++ /dev/null @@ -1,161 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from enum import Enum -from azure.core import CaseInsensitiveEnumMeta - - -class AccessPolicyUpdateKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """AccessPolicyUpdateKind.""" - - ADD = "add" - REPLACE = "replace" - REMOVE = "remove" - - -class CertificatePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """CertificatePermissions.""" - - GET = "get" - LIST = "list" - DELETE = "delete" - CREATE = "create" - IMPORT = "import" - UPDATE = "update" - MANAGECONTACTS = "managecontacts" - GETISSUERS = "getissuers" - LISTISSUERS = "listissuers" - SETISSUERS = "setissuers" - DELETEISSUERS = "deleteissuers" - MANAGEISSUERS = "manageissuers" - RECOVER = "recover" - PURGE = "purge" - BACKUP = "backup" - RESTORE = "restore" - IMPORT_ENUM = "import" - - -class CreateMode(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The vault's create mode to indicate whether the vault need to be recovered or not.""" - - RECOVER = "recover" - DEFAULT = "default" - - -class KeyPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """KeyPermissions.""" - - ENCRYPT = "encrypt" - DECRYPT = "decrypt" - WRAP_KEY = "wrapKey" - UNWRAP_KEY = "unwrapKey" - SIGN = "sign" - VERIFY = "verify" - GET = "get" - LIST = "list" - CREATE = "create" - UPDATE = "update" - IMPORT = "import" - DELETE = "delete" - BACKUP = "backup" - RESTORE = "restore" - RECOVER = "recover" - PURGE = "purge" - IMPORT_ENUM = "import" - - -class NetworkRuleAction(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The default action when no rule from ipRules and from virtualNetworkRules match. This is only - used after the bypass property has been evaluated. - """ - - ALLOW = "Allow" - DENY = "Deny" - - -class NetworkRuleBypassOptions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Tells what traffic can bypass network rules. This can be 'AzureServices' or 'None'. If not - specified the default is 'AzureServices'. - """ - - AZURE_SERVICES = "AzureServices" - NONE = "None" - - -class PrivateEndpointConnectionProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The current provisioning state.""" - - SUCCEEDED = "Succeeded" - CREATING = "Creating" - UPDATING = "Updating" - DELETING = "Deleting" - FAILED = "Failed" - DISCONNECTED = "Disconnected" - - -class PrivateEndpointServiceConnectionStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The private endpoint connection status.""" - - PENDING = "Pending" - APPROVED = "Approved" - REJECTED = "Rejected" - DISCONNECTED = "Disconnected" - - -class Reason(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The reason that a vault name could not be used. The Reason element is only returned if - NameAvailable is false. - """ - - ACCOUNT_NAME_INVALID = "AccountNameInvalid" - ALREADY_EXISTS = "AlreadyExists" - - -class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SecretPermissions.""" - - GET = "get" - LIST = "list" - SET = "set" - DELETE = "delete" - BACKUP = "backup" - RESTORE = "restore" - RECOVER = "recover" - PURGE = "purge" - - -class SkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU family name.""" - - A = "A" - - -class SkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU name to specify whether the key vault is a standard vault or a premium vault.""" - - STANDARD = "standard" - PREMIUM = "premium" - - -class StoragePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """StoragePermissions.""" - - GET = "get" - LIST = "list" - DELETE = "delete" - SET = "set" - UPDATE = "update" - REGENERATEKEY = "regeneratekey" - RECOVER = "recover" - PURGE = "purge" - BACKUP = "backup" - RESTORE = "restore" - SETSAS = "setsas" - LISTSAS = "listsas" - GETSAS = "getsas" - DELETESAS = "deletesas" diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/models/_models_py3.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/models/_models_py3.py deleted file mode 100644 index d02bdd742ee9..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/models/_models_py3.py +++ /dev/null @@ -1,1498 +0,0 @@ -# coding=utf-8 -# pylint: disable=too-many-lines -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from typing import Any, Dict, List, Optional, TYPE_CHECKING, Union - -from ... import _serialization - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from .. import models as _models - - -class AccessPolicyEntry(_serialization.Model): - """An identity that have access to the key vault. All identities in the array must use the same - tenant ID as the key vault's tenant ID. - - All required parameters must be populated in order to send to server. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :vartype tenant_id: str - :ivar object_id: The object ID of a user, service principal or security group in the Azure - Active Directory tenant for the vault. The object ID must be unique for the list of access - policies. Required. - :vartype object_id: str - :ivar application_id: Application ID of the client making request on behalf of a principal. - :vartype application_id: str - :ivar permissions: Permissions the identity has for keys, secrets and certificates. Required. - :vartype permissions: ~azure.mgmt.keyvault.v2018_02_14.models.Permissions - """ - - _validation = { - "tenant_id": {"required": True}, - "object_id": {"required": True}, - "permissions": {"required": True}, - } - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "object_id": {"key": "objectId", "type": "str"}, - "application_id": {"key": "applicationId", "type": "str"}, - "permissions": {"key": "permissions", "type": "Permissions"}, - } - - def __init__( - self, - *, - tenant_id: str, - object_id: str, - permissions: "_models.Permissions", - application_id: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :paramtype tenant_id: str - :keyword object_id: The object ID of a user, service principal or security group in the Azure - Active Directory tenant for the vault. The object ID must be unique for the list of access - policies. Required. - :paramtype object_id: str - :keyword application_id: Application ID of the client making request on behalf of a principal. - :paramtype application_id: str - :keyword permissions: Permissions the identity has for keys, secrets and certificates. - Required. - :paramtype permissions: ~azure.mgmt.keyvault.v2018_02_14.models.Permissions - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.object_id = object_id - self.application_id = application_id - self.permissions = permissions - - -class CheckNameAvailabilityResult(_serialization.Model): - """The CheckNameAvailability operation response. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar name_available: A boolean value that indicates whether the name is available for you to - use. If true, the name is available. If false, the name has already been taken or is invalid - and cannot be used. - :vartype name_available: bool - :ivar reason: The reason that a vault name could not be used. The Reason element is only - returned if NameAvailable is false. Known values are: "AccountNameInvalid" and "AlreadyExists". - :vartype reason: str or ~azure.mgmt.keyvault.v2018_02_14.models.Reason - :ivar message: An error message explaining the Reason value in more detail. - :vartype message: str - """ - - _validation = { - "name_available": {"readonly": True}, - "reason": {"readonly": True}, - "message": {"readonly": True}, - } - - _attribute_map = { - "name_available": {"key": "nameAvailable", "type": "bool"}, - "reason": {"key": "reason", "type": "str"}, - "message": {"key": "message", "type": "str"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.name_available = None - self.reason = None - self.message = None - - -class CloudErrorBody(_serialization.Model): - """An error response from Key Vault resource provider. - - :ivar code: Error code. This is a mnemonic that can be consumed programmatically. - :vartype code: str - :ivar message: User friendly error message. The message is typically localized and may vary - with service version. - :vartype message: str - """ - - _attribute_map = { - "code": {"key": "code", "type": "str"}, - "message": {"key": "message", "type": "str"}, - } - - def __init__(self, *, code: Optional[str] = None, message: Optional[str] = None, **kwargs: Any) -> None: - """ - :keyword code: Error code. This is a mnemonic that can be consumed programmatically. - :paramtype code: str - :keyword message: User friendly error message. The message is typically localized and may vary - with service version. - :paramtype message: str - """ - super().__init__(**kwargs) - self.code = code - self.message = message - - -class DeletedVault(_serialization.Model): - """Deleted vault information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The resource ID for the deleted key vault. - :vartype id: str - :ivar name: The name of the key vault. - :vartype name: str - :ivar type: The resource type of the key vault. - :vartype type: str - :ivar properties: Properties of the vault. - :vartype properties: ~azure.mgmt.keyvault.v2018_02_14.models.DeletedVaultProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "properties": {"key": "properties", "type": "DeletedVaultProperties"}, - } - - def __init__(self, *, properties: Optional["_models.DeletedVaultProperties"] = None, **kwargs: Any) -> None: - """ - :keyword properties: Properties of the vault. - :paramtype properties: ~azure.mgmt.keyvault.v2018_02_14.models.DeletedVaultProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.properties = properties - - -class DeletedVaultListResult(_serialization.Model): - """List of vaults. - - :ivar value: The list of deleted vaults. - :vartype value: list[~azure.mgmt.keyvault.v2018_02_14.models.DeletedVault] - :ivar next_link: The URL to get the next set of deleted vaults. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[DeletedVault]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.DeletedVault"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of deleted vaults. - :paramtype value: list[~azure.mgmt.keyvault.v2018_02_14.models.DeletedVault] - :keyword next_link: The URL to get the next set of deleted vaults. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class DeletedVaultProperties(_serialization.Model): - """Properties of the deleted vault. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar vault_id: The resource id of the original vault. - :vartype vault_id: str - :ivar location: The location of the original vault. - :vartype location: str - :ivar deletion_date: The deleted date. - :vartype deletion_date: ~datetime.datetime - :ivar scheduled_purge_date: The scheduled purged date. - :vartype scheduled_purge_date: ~datetime.datetime - :ivar tags: Tags of the original vault. - :vartype tags: dict[str, str] - """ - - _validation = { - "vault_id": {"readonly": True}, - "location": {"readonly": True}, - "deletion_date": {"readonly": True}, - "scheduled_purge_date": {"readonly": True}, - "tags": {"readonly": True}, - } - - _attribute_map = { - "vault_id": {"key": "vaultId", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "deletion_date": {"key": "deletionDate", "type": "iso-8601"}, - "scheduled_purge_date": {"key": "scheduledPurgeDate", "type": "iso-8601"}, - "tags": {"key": "tags", "type": "{str}"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.vault_id = None - self.location = None - self.deletion_date = None - self.scheduled_purge_date = None - self.tags = None - - -class IPRule(_serialization.Model): - """A rule governing the accessibility of a vault from a specific ip address or ip range. - - All required parameters must be populated in order to send to server. - - :ivar value: An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP address) - or '124.56.78.0/24' (all addresses that start with 124.56.78). Required. - :vartype value: str - """ - - _validation = { - "value": {"required": True}, - } - - _attribute_map = { - "value": {"key": "value", "type": "str"}, - } - - def __init__(self, *, value: str, **kwargs: Any) -> None: - """ - :keyword value: An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP - address) or '124.56.78.0/24' (all addresses that start with 124.56.78). Required. - :paramtype value: str - """ - super().__init__(**kwargs) - self.value = value - - -class LogSpecification(_serialization.Model): - """Log specification of operation. - - :ivar name: Name of log specification. - :vartype name: str - :ivar display_name: Display name of log specification. - :vartype display_name: str - :ivar blob_duration: Blob duration of specification. - :vartype blob_duration: str - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display_name": {"key": "displayName", "type": "str"}, - "blob_duration": {"key": "blobDuration", "type": "str"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display_name: Optional[str] = None, - blob_duration: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Name of log specification. - :paramtype name: str - :keyword display_name: Display name of log specification. - :paramtype display_name: str - :keyword blob_duration: Blob duration of specification. - :paramtype blob_duration: str - """ - super().__init__(**kwargs) - self.name = name - self.display_name = display_name - self.blob_duration = blob_duration - - -class NetworkRuleSet(_serialization.Model): - """A set of rules governing the network accessibility of a vault. - - :ivar bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or - 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and - "None". - :vartype bypass: str or ~azure.mgmt.keyvault.v2018_02_14.models.NetworkRuleBypassOptions - :ivar default_action: The default action when no rule from ipRules and from virtualNetworkRules - match. This is only used after the bypass property has been evaluated. Known values are: - "Allow" and "Deny". - :vartype default_action: str or ~azure.mgmt.keyvault.v2018_02_14.models.NetworkRuleAction - :ivar ip_rules: The list of IP address rules. - :vartype ip_rules: list[~azure.mgmt.keyvault.v2018_02_14.models.IPRule] - :ivar virtual_network_rules: The list of virtual network rules. - :vartype virtual_network_rules: - list[~azure.mgmt.keyvault.v2018_02_14.models.VirtualNetworkRule] - """ - - _attribute_map = { - "bypass": {"key": "bypass", "type": "str"}, - "default_action": {"key": "defaultAction", "type": "str"}, - "ip_rules": {"key": "ipRules", "type": "[IPRule]"}, - "virtual_network_rules": {"key": "virtualNetworkRules", "type": "[VirtualNetworkRule]"}, - } - - def __init__( - self, - *, - bypass: Optional[Union[str, "_models.NetworkRuleBypassOptions"]] = None, - default_action: Optional[Union[str, "_models.NetworkRuleAction"]] = None, - ip_rules: Optional[List["_models.IPRule"]] = None, - virtual_network_rules: Optional[List["_models.VirtualNetworkRule"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or - 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and - "None". - :paramtype bypass: str or ~azure.mgmt.keyvault.v2018_02_14.models.NetworkRuleBypassOptions - :keyword default_action: The default action when no rule from ipRules and from - virtualNetworkRules match. This is only used after the bypass property has been evaluated. - Known values are: "Allow" and "Deny". - :paramtype default_action: str or ~azure.mgmt.keyvault.v2018_02_14.models.NetworkRuleAction - :keyword ip_rules: The list of IP address rules. - :paramtype ip_rules: list[~azure.mgmt.keyvault.v2018_02_14.models.IPRule] - :keyword virtual_network_rules: The list of virtual network rules. - :paramtype virtual_network_rules: - list[~azure.mgmt.keyvault.v2018_02_14.models.VirtualNetworkRule] - """ - super().__init__(**kwargs) - self.bypass = bypass - self.default_action = default_action - self.ip_rules = ip_rules - self.virtual_network_rules = virtual_network_rules - - -class Operation(_serialization.Model): - """Key Vault REST API operation definition. - - :ivar name: Operation name: {provider}/{resource}/{operation}. - :vartype name: str - :ivar display: Display metadata associated with the operation. - :vartype display: ~azure.mgmt.keyvault.v2018_02_14.models.OperationDisplay - :ivar origin: The origin of operations. - :vartype origin: str - :ivar service_specification: One property of operation, include metric specifications. - :vartype service_specification: ~azure.mgmt.keyvault.v2018_02_14.models.ServiceSpecification - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display": {"key": "display", "type": "OperationDisplay"}, - "origin": {"key": "origin", "type": "str"}, - "service_specification": {"key": "properties.serviceSpecification", "type": "ServiceSpecification"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display: Optional["_models.OperationDisplay"] = None, - origin: Optional[str] = None, - service_specification: Optional["_models.ServiceSpecification"] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Operation name: {provider}/{resource}/{operation}. - :paramtype name: str - :keyword display: Display metadata associated with the operation. - :paramtype display: ~azure.mgmt.keyvault.v2018_02_14.models.OperationDisplay - :keyword origin: The origin of operations. - :paramtype origin: str - :keyword service_specification: One property of operation, include metric specifications. - :paramtype service_specification: ~azure.mgmt.keyvault.v2018_02_14.models.ServiceSpecification - """ - super().__init__(**kwargs) - self.name = name - self.display = display - self.origin = origin - self.service_specification = service_specification - - -class OperationDisplay(_serialization.Model): - """Display metadata associated with the operation. - - :ivar provider: Service provider: Microsoft Key Vault. - :vartype provider: str - :ivar resource: Resource on which the operation is performed etc. - :vartype resource: str - :ivar operation: Type of operation: get, read, delete, etc. - :vartype operation: str - :ivar description: Description of operation. - :vartype description: str - """ - - _attribute_map = { - "provider": {"key": "provider", "type": "str"}, - "resource": {"key": "resource", "type": "str"}, - "operation": {"key": "operation", "type": "str"}, - "description": {"key": "description", "type": "str"}, - } - - def __init__( - self, - *, - provider: Optional[str] = None, - resource: Optional[str] = None, - operation: Optional[str] = None, - description: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword provider: Service provider: Microsoft Key Vault. - :paramtype provider: str - :keyword resource: Resource on which the operation is performed etc. - :paramtype resource: str - :keyword operation: Type of operation: get, read, delete, etc. - :paramtype operation: str - :keyword description: Description of operation. - :paramtype description: str - """ - super().__init__(**kwargs) - self.provider = provider - self.resource = resource - self.operation = operation - self.description = description - - -class OperationListResult(_serialization.Model): - """Result of the request to list Storage operations. It contains a list of operations and a URL - link to get the next set of results. - - :ivar value: List of Storage operations supported by the Storage resource provider. - :vartype value: list[~azure.mgmt.keyvault.v2018_02_14.models.Operation] - :ivar next_link: The URL to get the next set of operations. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Operation]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Operation"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: List of Storage operations supported by the Storage resource provider. - :paramtype value: list[~azure.mgmt.keyvault.v2018_02_14.models.Operation] - :keyword next_link: The URL to get the next set of operations. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class Permissions(_serialization.Model): - """Permissions the identity has for keys, secrets, certificates and storage. - - :ivar keys: Permissions to keys. - :vartype keys: list[str or ~azure.mgmt.keyvault.v2018_02_14.models.KeyPermissions] - :ivar secrets: Permissions to secrets. - :vartype secrets: list[str or ~azure.mgmt.keyvault.v2018_02_14.models.SecretPermissions] - :ivar certificates: Permissions to certificates. - :vartype certificates: list[str or - ~azure.mgmt.keyvault.v2018_02_14.models.CertificatePermissions] - :ivar storage: Permissions to storage accounts. - :vartype storage: list[str or ~azure.mgmt.keyvault.v2018_02_14.models.StoragePermissions] - """ - - _attribute_map = { - "keys": {"key": "keys", "type": "[str]"}, - "secrets": {"key": "secrets", "type": "[str]"}, - "certificates": {"key": "certificates", "type": "[str]"}, - "storage": {"key": "storage", "type": "[str]"}, - } - - def __init__( - self, - *, - keys: Optional[List[Union[str, "_models.KeyPermissions"]]] = None, - secrets: Optional[List[Union[str, "_models.SecretPermissions"]]] = None, - certificates: Optional[List[Union[str, "_models.CertificatePermissions"]]] = None, - storage: Optional[List[Union[str, "_models.StoragePermissions"]]] = None, - **kwargs: Any - ) -> None: - """ - :keyword keys: Permissions to keys. - :paramtype keys: list[str or ~azure.mgmt.keyvault.v2018_02_14.models.KeyPermissions] - :keyword secrets: Permissions to secrets. - :paramtype secrets: list[str or ~azure.mgmt.keyvault.v2018_02_14.models.SecretPermissions] - :keyword certificates: Permissions to certificates. - :paramtype certificates: list[str or - ~azure.mgmt.keyvault.v2018_02_14.models.CertificatePermissions] - :keyword storage: Permissions to storage accounts. - :paramtype storage: list[str or ~azure.mgmt.keyvault.v2018_02_14.models.StoragePermissions] - """ - super().__init__(**kwargs) - self.keys = keys - self.secrets = secrets - self.certificates = certificates - self.storage = storage - - -class PrivateEndpoint(_serialization.Model): - """Private endpoint object properties. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Full identifier of the private endpoint resource. - :vartype id: str - """ - - _validation = { - "id": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.id = None - - -class Resource(_serialization.Model): - """Key Vault resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = None - self.tags = None - - -class PrivateEndpointConnection(Resource): - """Private endpoint connection resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpoint - :ivar private_link_service_connection_state: Approval state of the private link connection. - :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2018_02_14.models.PrivateLinkServiceConnectionState - :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values - are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnectionProvisioningState - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - "provisioning_state": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "private_endpoint": {"key": "properties.privateEndpoint", "type": "PrivateEndpoint"}, - "private_link_service_connection_state": { - "key": "properties.privateLinkServiceConnectionState", - "type": "PrivateLinkServiceConnectionState", - }, - "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - private_endpoint: Optional["_models.PrivateEndpoint"] = None, - private_link_service_connection_state: Optional["_models.PrivateLinkServiceConnectionState"] = None, - **kwargs: Any - ) -> None: - """ - :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpoint - :keyword private_link_service_connection_state: Approval state of the private link connection. - :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2018_02_14.models.PrivateLinkServiceConnectionState - """ - super().__init__(**kwargs) - self.private_endpoint = private_endpoint - self.private_link_service_connection_state = private_link_service_connection_state - self.provisioning_state = None - - -class PrivateEndpointConnectionItem(_serialization.Model): - """Private endpoint connection item. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpoint - :ivar private_link_service_connection_state: Approval state of the private link connection. - :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2018_02_14.models.PrivateLinkServiceConnectionState - :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values - are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnectionProvisioningState - """ - - _validation = { - "provisioning_state": {"readonly": True}, - } - - _attribute_map = { - "private_endpoint": {"key": "properties.privateEndpoint", "type": "PrivateEndpoint"}, - "private_link_service_connection_state": { - "key": "properties.privateLinkServiceConnectionState", - "type": "PrivateLinkServiceConnectionState", - }, - "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - private_endpoint: Optional["_models.PrivateEndpoint"] = None, - private_link_service_connection_state: Optional["_models.PrivateLinkServiceConnectionState"] = None, - **kwargs: Any - ) -> None: - """ - :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpoint - :keyword private_link_service_connection_state: Approval state of the private link connection. - :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2018_02_14.models.PrivateLinkServiceConnectionState - """ - super().__init__(**kwargs) - self.private_endpoint = private_endpoint - self.private_link_service_connection_state = private_link_service_connection_state - self.provisioning_state = None - - -class PrivateLinkResource(Resource): - """A private link resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar group_id: Group identifier of private link resource. - :vartype group_id: str - :ivar required_members: Required member names of private link resource. - :vartype required_members: list[str] - :ivar required_zone_names: Required DNS zone names of the the private link resource. - :vartype required_zone_names: list[str] - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - "group_id": {"readonly": True}, - "required_members": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "group_id": {"key": "properties.groupId", "type": "str"}, - "required_members": {"key": "properties.requiredMembers", "type": "[str]"}, - "required_zone_names": {"key": "properties.requiredZoneNames", "type": "[str]"}, - } - - def __init__(self, *, required_zone_names: Optional[List[str]] = None, **kwargs: Any) -> None: - """ - :keyword required_zone_names: Required DNS zone names of the the private link resource. - :paramtype required_zone_names: list[str] - """ - super().__init__(**kwargs) - self.group_id = None - self.required_members = None - self.required_zone_names = required_zone_names - - -class PrivateLinkResourceListResult(_serialization.Model): - """A list of private link resources. - - :ivar value: Array of private link resources. - :vartype value: list[~azure.mgmt.keyvault.v2018_02_14.models.PrivateLinkResource] - """ - - _attribute_map = { - "value": {"key": "value", "type": "[PrivateLinkResource]"}, - } - - def __init__(self, *, value: Optional[List["_models.PrivateLinkResource"]] = None, **kwargs: Any) -> None: - """ - :keyword value: Array of private link resources. - :paramtype value: list[~azure.mgmt.keyvault.v2018_02_14.models.PrivateLinkResource] - """ - super().__init__(**kwargs) - self.value = value - - -class PrivateLinkServiceConnectionState(_serialization.Model): - """An object that represents the approval state of the private link connection. - - :ivar status: Indicates whether the connection has been approved, rejected or removed by the - key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :vartype status: str or - ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointServiceConnectionStatus - :ivar description: The reason for approval or rejection. - :vartype description: str - :ivar action_required: A message indicating if changes on the service provider require any - updates on the consumer. - :vartype action_required: str - """ - - _attribute_map = { - "status": {"key": "status", "type": "str"}, - "description": {"key": "description", "type": "str"}, - "action_required": {"key": "actionRequired", "type": "str"}, - } - - def __init__( - self, - *, - status: Optional[Union[str, "_models.PrivateEndpointServiceConnectionStatus"]] = None, - description: Optional[str] = None, - action_required: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword status: Indicates whether the connection has been approved, rejected or removed by the - key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :paramtype status: str or - ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointServiceConnectionStatus - :keyword description: The reason for approval or rejection. - :paramtype description: str - :keyword action_required: A message indicating if changes on the service provider require any - updates on the consumer. - :paramtype action_required: str - """ - super().__init__(**kwargs) - self.status = status - self.description = description - self.action_required = action_required - - -class ResourceListResult(_serialization.Model): - """List of vault resources. - - :ivar value: The list of vault resources. - :vartype value: list[~azure.mgmt.keyvault.v2018_02_14.models.Resource] - :ivar next_link: The URL to get the next set of vault resources. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Resource]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Resource"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of vault resources. - :paramtype value: list[~azure.mgmt.keyvault.v2018_02_14.models.Resource] - :keyword next_link: The URL to get the next set of vault resources. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class ServiceSpecification(_serialization.Model): - """One property of operation, include log specifications. - - :ivar log_specifications: Log specifications of operation. - :vartype log_specifications: list[~azure.mgmt.keyvault.v2018_02_14.models.LogSpecification] - """ - - _attribute_map = { - "log_specifications": {"key": "logSpecifications", "type": "[LogSpecification]"}, - } - - def __init__(self, *, log_specifications: Optional[List["_models.LogSpecification"]] = None, **kwargs: Any) -> None: - """ - :keyword log_specifications: Log specifications of operation. - :paramtype log_specifications: list[~azure.mgmt.keyvault.v2018_02_14.models.LogSpecification] - """ - super().__init__(**kwargs) - self.log_specifications = log_specifications - - -class Sku(_serialization.Model): - """SKU details. - - All required parameters must be populated in order to send to server. - - :ivar family: SKU family name. "A" - :vartype family: str or ~azure.mgmt.keyvault.v2018_02_14.models.SkuFamily - :ivar name: SKU name to specify whether the key vault is a standard vault or a premium vault. - Required. Known values are: "standard" and "premium". - :vartype name: str or ~azure.mgmt.keyvault.v2018_02_14.models.SkuName - """ - - _validation = { - "family": {"required": True}, - "name": {"required": True}, - } - - _attribute_map = { - "family": {"key": "family", "type": "str"}, - "name": {"key": "name", "type": "str"}, - } - - def __init__( - self, *, family: Union[str, "_models.SkuFamily"] = "A", name: Union[str, "_models.SkuName"], **kwargs: Any - ) -> None: - """ - :keyword family: SKU family name. "A" - :paramtype family: str or ~azure.mgmt.keyvault.v2018_02_14.models.SkuFamily - :keyword name: SKU name to specify whether the key vault is a standard vault or a premium - vault. Required. Known values are: "standard" and "premium". - :paramtype name: str or ~azure.mgmt.keyvault.v2018_02_14.models.SkuName - """ - super().__init__(**kwargs) - self.family = family - self.name = name - - -class Vault(_serialization.Model): - """Resource information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar properties: Properties of the vault. Required. - :vartype properties: ~azure.mgmt.keyvault.v2018_02_14.models.VaultProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "VaultProperties"}, - } - - def __init__( - self, - *, - properties: "_models.VaultProperties", - location: Optional[str] = None, - tags: Optional[Dict[str, str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: Azure location of the key vault resource. - :paramtype location: str - :keyword tags: Tags assigned to the key vault resource. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the vault. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2018_02_14.models.VaultProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = location - self.tags = tags - self.properties = properties - - -class VaultAccessPolicyParameters(_serialization.Model): - """Parameters for updating the access policy in a vault. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar id: The resource id of the access policy. - :vartype id: str - :ivar name: The resource name of the access policy. - :vartype name: str - :ivar type: The resource name of the access policy. - :vartype type: str - :ivar location: The resource type of the access policy. - :vartype location: str - :ivar properties: Properties of the access policy. Required. - :vartype properties: ~azure.mgmt.keyvault.v2018_02_14.models.VaultAccessPolicyProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "properties": {"key": "properties", "type": "VaultAccessPolicyProperties"}, - } - - def __init__(self, *, properties: "_models.VaultAccessPolicyProperties", **kwargs: Any) -> None: - """ - :keyword properties: Properties of the access policy. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2018_02_14.models.VaultAccessPolicyProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = None - self.properties = properties - - -class VaultAccessPolicyProperties(_serialization.Model): - """Properties of the vault access policy. - - All required parameters must be populated in order to send to server. - - :ivar access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. Required. - :vartype access_policies: list[~azure.mgmt.keyvault.v2018_02_14.models.AccessPolicyEntry] - """ - - _validation = { - "access_policies": {"required": True}, - } - - _attribute_map = { - "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, - } - - def __init__(self, *, access_policies: List["_models.AccessPolicyEntry"], **kwargs: Any) -> None: - """ - :keyword access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. Required. - :paramtype access_policies: list[~azure.mgmt.keyvault.v2018_02_14.models.AccessPolicyEntry] - """ - super().__init__(**kwargs) - self.access_policies = access_policies - - -class VaultCheckNameAvailabilityParameters(_serialization.Model): - """The parameters used to check the availability of the vault name. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar name: The vault name. Required. - :vartype name: str - :ivar type: The type of resource, Microsoft.KeyVault/vaults. Required. Default value is - "Microsoft.KeyVault/vaults". - :vartype type: str - """ - - _validation = { - "name": {"required": True}, - "type": {"required": True, "constant": True}, - } - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - } - - type = "Microsoft.KeyVault/vaults" - - def __init__(self, *, name: str, **kwargs: Any) -> None: - """ - :keyword name: The vault name. Required. - :paramtype name: str - """ - super().__init__(**kwargs) - self.name = name - - -class VaultCreateOrUpdateParameters(_serialization.Model): - """Parameters for creating or updating a vault. - - All required parameters must be populated in order to send to server. - - :ivar location: The supported Azure location where the key vault should be created. Required. - :vartype location: str - :ivar tags: The tags that will be assigned to the key vault. - :vartype tags: dict[str, str] - :ivar properties: Properties of the vault. Required. - :vartype properties: ~azure.mgmt.keyvault.v2018_02_14.models.VaultProperties - """ - - _validation = { - "location": {"required": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "VaultProperties"}, - } - - def __init__( - self, - *, - location: str, - properties: "_models.VaultProperties", - tags: Optional[Dict[str, str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the key vault should be created. - Required. - :paramtype location: str - :keyword tags: The tags that will be assigned to the key vault. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the vault. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2018_02_14.models.VaultProperties - """ - super().__init__(**kwargs) - self.location = location - self.tags = tags - self.properties = properties - - -class VaultListResult(_serialization.Model): - """List of vaults. - - :ivar value: The list of vaults. - :vartype value: list[~azure.mgmt.keyvault.v2018_02_14.models.Vault] - :ivar next_link: The URL to get the next set of vaults. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Vault]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Vault"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of vaults. - :paramtype value: list[~azure.mgmt.keyvault.v2018_02_14.models.Vault] - :keyword next_link: The URL to get the next set of vaults. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class VaultPatchParameters(_serialization.Model): - """Parameters for creating or updating a vault. - - :ivar tags: The tags that will be assigned to the key vault. - :vartype tags: dict[str, str] - :ivar properties: Properties of the vault. - :vartype properties: ~azure.mgmt.keyvault.v2018_02_14.models.VaultPatchProperties - """ - - _attribute_map = { - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "VaultPatchProperties"}, - } - - def __init__( - self, - *, - tags: Optional[Dict[str, str]] = None, - properties: Optional["_models.VaultPatchProperties"] = None, - **kwargs: Any - ) -> None: - """ - :keyword tags: The tags that will be assigned to the key vault. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the vault. - :paramtype properties: ~azure.mgmt.keyvault.v2018_02_14.models.VaultPatchProperties - """ - super().__init__(**kwargs) - self.tags = tags - self.properties = properties - - -class VaultPatchProperties(_serialization.Model): - """Properties of the vault. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. - :vartype tenant_id: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2018_02_14.models.Sku - :ivar access_policies: An array of 0 to 1024 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. - :vartype access_policies: list[~azure.mgmt.keyvault.v2018_02_14.models.AccessPolicyEntry] - :ivar enabled_for_deployment: Property to specify whether Azure Virtual Machines are permitted - to retrieve certificates stored as secrets from the key vault. - :vartype enabled_for_deployment: bool - :ivar enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :vartype enabled_for_disk_encryption: bool - :ivar enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :vartype enabled_for_template_deployment: bool - :ivar enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. It does not accept false value. - :vartype enable_soft_delete: bool - :ivar create_mode: The vault's create mode to indicate whether the vault need to be recovered - or not. Known values are: "recover" and "default". - :vartype create_mode: str or ~azure.mgmt.keyvault.v2018_02_14.models.CreateMode - :ivar enable_purge_protection: Property specifying whether protection against purge is enabled - for this vault. Setting this property to true activates protection against purge for this vault - and its content - only the Key Vault service may initiate a hard, irrecoverable deletion. The - setting is effective only if soft delete is also enabled. Enabling this functionality is - irreversible - that is, the property does not accept false as its value. - :vartype enable_purge_protection: bool - :ivar network_acls: A collection of rules governing the accessibility of the vault from - specific network locations. - :vartype network_acls: ~azure.mgmt.keyvault.v2018_02_14.models.NetworkRuleSet - """ - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "sku": {"key": "sku", "type": "Sku"}, - "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, - "enabled_for_deployment": {"key": "enabledForDeployment", "type": "bool"}, - "enabled_for_disk_encryption": {"key": "enabledForDiskEncryption", "type": "bool"}, - "enabled_for_template_deployment": {"key": "enabledForTemplateDeployment", "type": "bool"}, - "enable_soft_delete": {"key": "enableSoftDelete", "type": "bool"}, - "create_mode": {"key": "createMode", "type": "str"}, - "enable_purge_protection": {"key": "enablePurgeProtection", "type": "bool"}, - "network_acls": {"key": "networkAcls", "type": "NetworkRuleSet"}, - } - - def __init__( - self, - *, - tenant_id: Optional[str] = None, - sku: Optional["_models.Sku"] = None, - access_policies: Optional[List["_models.AccessPolicyEntry"]] = None, - enabled_for_deployment: Optional[bool] = None, - enabled_for_disk_encryption: Optional[bool] = None, - enabled_for_template_deployment: Optional[bool] = None, - enable_soft_delete: Optional[bool] = None, - create_mode: Optional[Union[str, "_models.CreateMode"]] = None, - enable_purge_protection: Optional[bool] = None, - network_acls: Optional["_models.NetworkRuleSet"] = None, - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. - :paramtype tenant_id: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2018_02_14.models.Sku - :keyword access_policies: An array of 0 to 1024 identities that have access to the key vault. - All identities in the array must use the same tenant ID as the key vault's tenant ID. - :paramtype access_policies: list[~azure.mgmt.keyvault.v2018_02_14.models.AccessPolicyEntry] - :keyword enabled_for_deployment: Property to specify whether Azure Virtual Machines are - permitted to retrieve certificates stored as secrets from the key vault. - :paramtype enabled_for_deployment: bool - :keyword enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :paramtype enabled_for_disk_encryption: bool - :keyword enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :paramtype enabled_for_template_deployment: bool - :keyword enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. It does not accept false value. - :paramtype enable_soft_delete: bool - :keyword create_mode: The vault's create mode to indicate whether the vault need to be - recovered or not. Known values are: "recover" and "default". - :paramtype create_mode: str or ~azure.mgmt.keyvault.v2018_02_14.models.CreateMode - :keyword enable_purge_protection: Property specifying whether protection against purge is - enabled for this vault. Setting this property to true activates protection against purge for - this vault and its content - only the Key Vault service may initiate a hard, irrecoverable - deletion. The setting is effective only if soft delete is also enabled. Enabling this - functionality is irreversible - that is, the property does not accept false as its value. - :paramtype enable_purge_protection: bool - :keyword network_acls: A collection of rules governing the accessibility of the vault from - specific network locations. - :paramtype network_acls: ~azure.mgmt.keyvault.v2018_02_14.models.NetworkRuleSet - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.sku = sku - self.access_policies = access_policies - self.enabled_for_deployment = enabled_for_deployment - self.enabled_for_disk_encryption = enabled_for_disk_encryption - self.enabled_for_template_deployment = enabled_for_template_deployment - self.enable_soft_delete = enable_soft_delete - self.create_mode = create_mode - self.enable_purge_protection = enable_purge_protection - self.network_acls = network_acls - - -class VaultProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Properties of the vault. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :vartype tenant_id: str - :ivar sku: SKU details. Required. - :vartype sku: ~azure.mgmt.keyvault.v2018_02_14.models.Sku - :ivar access_policies: An array of 0 to 1024 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. When - ``createMode`` is set to ``recover``\\ , access policies are not required. Otherwise, access - policies are required. - :vartype access_policies: list[~azure.mgmt.keyvault.v2018_02_14.models.AccessPolicyEntry] - :ivar vault_uri: The URI of the vault for performing operations on keys and secrets. - :vartype vault_uri: str - :ivar enabled_for_deployment: Property to specify whether Azure Virtual Machines are permitted - to retrieve certificates stored as secrets from the key vault. - :vartype enabled_for_deployment: bool - :ivar enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :vartype enabled_for_disk_encryption: bool - :ivar enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :vartype enabled_for_template_deployment: bool - :ivar enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. It does not accept false value. - :vartype enable_soft_delete: bool - :ivar create_mode: The vault's create mode to indicate whether the vault need to be recovered - or not. Known values are: "recover" and "default". - :vartype create_mode: str or ~azure.mgmt.keyvault.v2018_02_14.models.CreateMode - :ivar enable_purge_protection: Property specifying whether protection against purge is enabled - for this vault. Setting this property to true activates protection against purge for this vault - and its content - only the Key Vault service may initiate a hard, irrecoverable deletion. The - setting is effective only if soft delete is also enabled. Enabling this functionality is - irreversible - that is, the property does not accept false as its value. - :vartype enable_purge_protection: bool - :ivar network_acls: Rules governing the accessibility of the key vault from specific network - locations. - :vartype network_acls: ~azure.mgmt.keyvault.v2018_02_14.models.NetworkRuleSet - :ivar private_endpoint_connections: List of private endpoint connections associated with the - key vault. - :vartype private_endpoint_connections: - list[~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnectionItem] - """ - - _validation = { - "tenant_id": {"required": True}, - "sku": {"required": True}, - "private_endpoint_connections": {"readonly": True}, - } - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "sku": {"key": "sku", "type": "Sku"}, - "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, - "vault_uri": {"key": "vaultUri", "type": "str"}, - "enabled_for_deployment": {"key": "enabledForDeployment", "type": "bool"}, - "enabled_for_disk_encryption": {"key": "enabledForDiskEncryption", "type": "bool"}, - "enabled_for_template_deployment": {"key": "enabledForTemplateDeployment", "type": "bool"}, - "enable_soft_delete": {"key": "enableSoftDelete", "type": "bool"}, - "create_mode": {"key": "createMode", "type": "str"}, - "enable_purge_protection": {"key": "enablePurgeProtection", "type": "bool"}, - "network_acls": {"key": "networkAcls", "type": "NetworkRuleSet"}, - "private_endpoint_connections": { - "key": "privateEndpointConnections", - "type": "[PrivateEndpointConnectionItem]", - }, - } - - def __init__( - self, - *, - tenant_id: str, - sku: "_models.Sku", - access_policies: Optional[List["_models.AccessPolicyEntry"]] = None, - vault_uri: Optional[str] = None, - enabled_for_deployment: Optional[bool] = None, - enabled_for_disk_encryption: Optional[bool] = None, - enabled_for_template_deployment: Optional[bool] = None, - enable_soft_delete: Optional[bool] = None, - create_mode: Optional[Union[str, "_models.CreateMode"]] = None, - enable_purge_protection: Optional[bool] = None, - network_acls: Optional["_models.NetworkRuleSet"] = None, - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :paramtype tenant_id: str - :keyword sku: SKU details. Required. - :paramtype sku: ~azure.mgmt.keyvault.v2018_02_14.models.Sku - :keyword access_policies: An array of 0 to 1024 identities that have access to the key vault. - All identities in the array must use the same tenant ID as the key vault's tenant ID. When - ``createMode`` is set to ``recover``\\ , access policies are not required. Otherwise, access - policies are required. - :paramtype access_policies: list[~azure.mgmt.keyvault.v2018_02_14.models.AccessPolicyEntry] - :keyword vault_uri: The URI of the vault for performing operations on keys and secrets. - :paramtype vault_uri: str - :keyword enabled_for_deployment: Property to specify whether Azure Virtual Machines are - permitted to retrieve certificates stored as secrets from the key vault. - :paramtype enabled_for_deployment: bool - :keyword enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :paramtype enabled_for_disk_encryption: bool - :keyword enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :paramtype enabled_for_template_deployment: bool - :keyword enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. It does not accept false value. - :paramtype enable_soft_delete: bool - :keyword create_mode: The vault's create mode to indicate whether the vault need to be - recovered or not. Known values are: "recover" and "default". - :paramtype create_mode: str or ~azure.mgmt.keyvault.v2018_02_14.models.CreateMode - :keyword enable_purge_protection: Property specifying whether protection against purge is - enabled for this vault. Setting this property to true activates protection against purge for - this vault and its content - only the Key Vault service may initiate a hard, irrecoverable - deletion. The setting is effective only if soft delete is also enabled. Enabling this - functionality is irreversible - that is, the property does not accept false as its value. - :paramtype enable_purge_protection: bool - :keyword network_acls: Rules governing the accessibility of the key vault from specific network - locations. - :paramtype network_acls: ~azure.mgmt.keyvault.v2018_02_14.models.NetworkRuleSet - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.sku = sku - self.access_policies = access_policies - self.vault_uri = vault_uri - self.enabled_for_deployment = enabled_for_deployment - self.enabled_for_disk_encryption = enabled_for_disk_encryption - self.enabled_for_template_deployment = enabled_for_template_deployment - self.enable_soft_delete = enable_soft_delete - self.create_mode = create_mode - self.enable_purge_protection = enable_purge_protection - self.network_acls = network_acls - self.private_endpoint_connections = None - - -class VirtualNetworkRule(_serialization.Model): - """A rule governing the accessibility of a vault from a specific virtual network. - - All required parameters must be populated in order to send to server. - - :ivar id: Full resource id of a vnet subnet, such as - '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. - Required. - :vartype id: str - """ - - _validation = { - "id": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - } - - def __init__(self, *, id: str, **kwargs: Any) -> None: # pylint: disable=redefined-builtin - """ - :keyword id: Full resource id of a vnet subnet, such as - '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. # pylint: disable=line-too-long - Required. - :paramtype id: str - """ - super().__init__(**kwargs) - self.id = id diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/operations/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/operations/__init__.py deleted file mode 100644 index cab449d09e5b..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/operations/__init__.py +++ /dev/null @@ -1,25 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._vaults_operations import VaultsOperations -from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations -from ._private_link_resources_operations import PrivateLinkResourcesOperations -from ._operations import Operations - -from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "VaultsOperations", - "PrivateEndpointConnectionsOperations", - "PrivateLinkResourcesOperations", - "Operations", -] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/operations/_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/operations/_operations.py deleted file mode 100644 index fd2835d74db8..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/operations/_operations.py +++ /dev/null @@ -1,152 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Iterable, Optional, Type, TypeVar -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_request(**kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/providers/Microsoft.KeyVault/operations") - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class Operations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2018_02_14.KeyVaultManagementClient`'s - :attr:`operations` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: - """Lists all of the available Key Vault Rest API operations. - - :return: An iterator like instance of either Operation or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2018_02_14.models.Operation] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("OperationListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/operations/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/operations/_patch.py deleted file mode 100644 index 2bd66104efdb..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/operations/_patch.py +++ /dev/null @@ -1,134 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -import sys -from typing import Any, List, Iterable, Optional, Type -import urllib.parse - -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.rest import HttpRequest -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ._vaults_operations import VaultsOperations as _VaultsOperations, ClsType, build_list_request -from .. import models as _models - -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports - -class VaultsOperations(_VaultsOperations): - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2018_02_14.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - -__all__: List[str] = ["VaultsOperations"] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/operations/_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/operations/_private_endpoint_connections_operations.py deleted file mode 100644 index cdc1d03f1766..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/operations/_private_endpoint_connections_operations.py +++ /dev/null @@ -1,507 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterator, Optional, Type, TypeVar, Union, cast, overload - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_get_request( - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_put_request( - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request( - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -class PrivateEndpointConnectionsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2018_02_14.KeyVaultManagementClient`'s - :attr:`private_endpoint_connections` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def get( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Gets the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: _models.PrivateEndpointConnection, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: Union[_models.PrivateEndpointConnection, IO[bytes]], - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Is either a - PrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection or - IO[bytes] - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _json = self._serialize.body(properties, "PrivateEndpointConnection") - - _request = build_put_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Azure-AsyncOperation"] = self._deserialize( - "str", response.headers.get("Azure-AsyncOperation") - ) - - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - def _delete_initial( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_delete( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> LROPoller[_models.PrivateEndpointConnection]: - """Deletes the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: An instance of LROPoller that returns either PrivateEndpointConnection or the result - of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._delete_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.PrivateEndpointConnection].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.PrivateEndpointConnection]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/operations/_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/operations/_private_link_resources_operations.py deleted file mode 100644 index e01e1fc771f7..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/operations/_private_link_resources_operations.py +++ /dev/null @@ -1,145 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_by_vault_request( - resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class PrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2018_02_14.KeyVaultManagementClient`'s - :attr:`private_link_resources` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list_by_vault( - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> _models.PrivateLinkResourceListResult: - """Gets the private link resources supported for the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :return: PrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateLinkResourceListResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - cls: ClsType[_models.PrivateLinkResourceListResult] = kwargs.pop("cls", None) - - _request = build_list_by_vault_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/operations/_vaults_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/operations/_vaults_operations.py deleted file mode 100644 index 91437b9b286a..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/operations/_vaults_operations.py +++ /dev/null @@ -1,1569 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Literal, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_or_update_request( - resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, **kwargs) - - -def build_get_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_access_policy_request( - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "operationKind": _SERIALIZER.url("operation_kind", operation_kind, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_resource_group_request( - resource_group_name: str, subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_subscription_request( - subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_deleted_request(subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_deleted_request(vault_name: str, location: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "location": _SERIALIZER.url("location", location, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_purge_deleted_request(vault_name: str, location: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge", - ) # pylint: disable=line-too-long - path_format_arguments = { - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "location": _SERIALIZER.url("location", location, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - return HttpRequest(method="POST", url=_url, params=_params, **kwargs) - - -def build_list_request(subscription_id: str, *, top: Optional[int] = None, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop("api_version", _params.pop("api-version", "2015-11-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resources") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["$filter"] = _SERIALIZER.query("filter", filter, "str") - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_check_name_availability_request(subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability" - ) - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -class VaultsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2018_02_14.KeyVaultManagementClient`'s - :attr:`vaults` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - def _create_or_update_initial( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 201: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2018_02_14.models.VaultCreateOrUpdateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2018_02_14.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2018_02_14.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> LROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Is either a - VaultCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2018_02_14.models.VaultCreateOrUpdateParameters or - IO[bytes] - :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2018_02_14.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._create_or_update_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("Vault", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.Vault].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.Vault]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @overload - def update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultPatchParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2018_02_14.models.VaultPatchParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultPatchParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Is either a VaultPatchParameters type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2018_02_14.models.VaultPatchParameters or IO[bytes] - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultPatchParameters") - - _request = build_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def delete( # pylint: disable=inconsistent-return-statements - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> None: - """Deletes the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault to delete. Required. - :type vault_name: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - @distributed_trace - def get(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> _models.Vault: - """Gets the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: _models.VaultAccessPolicyParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2018_02_14.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2018_02_14.models.VaultAccessPolicyParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2018_02_14.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: Union[_models.VaultAccessPolicyParameters, IO[bytes]], - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2018_02_14.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Is either a - VaultAccessPolicyParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2018_02_14.models.VaultAccessPolicyParameters or - IO[bytes] - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.VaultAccessPolicyParameters] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") - - _request = build_update_access_policy_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - operation_kind=operation_kind, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> Iterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription and - within the specified resource group. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2018_02_14.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2018_02_14.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedVault"]: - """Gets information about the deleted vaults in a subscription. - - :return: An iterator like instance of either DeletedVault or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2018_02_14.models.DeletedVault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - cls: ClsType[_models.DeletedVaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("DeletedVaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _models.DeletedVault: - """Gets the deleted Azure key vault. - - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param location: The location of the deleted vault. Required. - :type location: str - :return: DeletedVault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.DeletedVault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - cls: ClsType[_models.DeletedVault] = kwargs.pop("cls", None) - - _request = build_get_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("DeletedVault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_purge_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_purge_deleted(self, vault_name: str, location: str, **kwargs: Any) -> LROPoller[None]: - """Permanently deletes the specified vault. aka Purges the deleted Azure key vault. - - :param vault_name: The name of the soft-deleted vault. Required. - :type vault_name: str - :param location: The location of the soft-deleted vault. Required. - :type location: str - :return: An instance of LROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._purge_deleted_initial( - vault_name=vault_name, - location=location, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2018_02_14.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @overload - def check_name_availability( - self, - vault_name: _models.VaultCheckNameAvailabilityParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: ~azure.mgmt.keyvault.v2018_02_14.models.VaultCheckNameAvailabilityParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def check_name_availability( - self, vault_name: IO[bytes], *, content_type: str = "application/json", **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def check_name_availability( - self, vault_name: Union[_models.VaultCheckNameAvailabilityParameters, IO[bytes]], **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Is either a VaultCheckNameAvailabilityParameters type - or a IO[bytes] type. Required. - :type vault_name: ~azure.mgmt.keyvault.v2018_02_14.models.VaultCheckNameAvailabilityParameters - or IO[bytes] - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.CheckNameAvailabilityResult] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(vault_name, (IOBase, bytes)): - _content = vault_name - else: - _json = self._serialize.body(vault_name, "VaultCheckNameAvailabilityParameters") - - _request = build_check_name_availability_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/__init__.py deleted file mode 100644 index 6bb4b7c63a45..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/__init__.py +++ /dev/null @@ -1,26 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._key_vault_management_client import KeyVaultManagementClient -from ._version import VERSION - -__version__ = VERSION - -try: - from ._patch import __all__ as _patch_all - from ._patch import * # pylint: disable=unused-wildcard-import -except ImportError: - _patch_all = [] -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "KeyVaultManagementClient", -] -__all__.extend([p for p in _patch_all if p not in __all__]) - -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/_configuration.py deleted file mode 100644 index 363bc89188eb..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/_configuration.py +++ /dev/null @@ -1,66 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from typing import Any, TYPE_CHECKING - -from azure.core.pipeline import policies -from azure.mgmt.core.policies import ARMChallengeAuthenticationPolicy, ARMHttpLoggingPolicy - -from ._version import VERSION - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials import TokenCredential - - -class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long - """Configuration for KeyVaultManagementClient. - - Note that all parameters used to create this instance are saved as instance - attributes. - - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials.TokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :keyword api_version: Api Version. Default value is "2019-09-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str - """ - - def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None: - api_version: str = kwargs.pop("api_version", "2019-09-01") - - if credential is None: - raise ValueError("Parameter 'credential' must not be None.") - if subscription_id is None: - raise ValueError("Parameter 'subscription_id' must not be None.") - - self.credential = credential - self.subscription_id = subscription_id - self.api_version = api_version - self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) - kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) - self.polling_interval = kwargs.get("polling_interval", 30) - self._configure(**kwargs) - - def _configure(self, **kwargs: Any) -> None: - 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.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**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) - self.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs) - self.authentication_policy = kwargs.get("authentication_policy") - if self.credential and not self.authentication_policy: - self.authentication_policy = ARMChallengeAuthenticationPolicy( - self.credential, *self.credential_scopes, **kwargs - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/_key_vault_management_client.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/_key_vault_management_client.py deleted file mode 100644 index 704c698ed731..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/_key_vault_management_client.py +++ /dev/null @@ -1,138 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from copy import deepcopy -from typing import Any, TYPE_CHECKING -from typing_extensions import Self - -from azure.core.pipeline import policies -from azure.core.rest import HttpRequest, HttpResponse -from azure.mgmt.core import ARMPipelineClient -from azure.mgmt.core.policies import ARMAutoResourceProviderRegistrationPolicy - -from . import models as _models -from .._serialization import Deserializer, Serializer -from ._configuration import KeyVaultManagementClientConfiguration -from .operations import ( - KeysOperations, - Operations, - PrivateEndpointConnectionsOperations, - PrivateLinkResourcesOperations, - VaultsOperations, -) - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials import TokenCredential - - -class KeyVaultManagementClient: # pylint: disable=client-accepts-api-version-keyword - """The Azure management API provides a RESTful set of web services that interact with Azure Key - Vault. - - :ivar vaults: VaultsOperations operations - :vartype vaults: azure.mgmt.keyvault.v2019_09_01.operations.VaultsOperations - :ivar private_endpoint_connections: PrivateEndpointConnectionsOperations operations - :vartype private_endpoint_connections: - azure.mgmt.keyvault.v2019_09_01.operations.PrivateEndpointConnectionsOperations - :ivar private_link_resources: PrivateLinkResourcesOperations operations - :vartype private_link_resources: - azure.mgmt.keyvault.v2019_09_01.operations.PrivateLinkResourcesOperations - :ivar operations: Operations operations - :vartype operations: azure.mgmt.keyvault.v2019_09_01.operations.Operations - :ivar keys: KeysOperations operations - :vartype keys: azure.mgmt.keyvault.v2019_09_01.operations.KeysOperations - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials.TokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :param base_url: Service URL. Default value is "https://management.azure.com". - :type base_url: str - :keyword api_version: Api Version. Default value is "2019-09-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. - """ - - def __init__( - self, - credential: "TokenCredential", - subscription_id: str, - base_url: str = "https://management.azure.com", - **kwargs: Any - ) -> None: - self._config = KeyVaultManagementClientConfiguration( - credential=credential, subscription_id=subscription_id, **kwargs - ) - _policies = kwargs.pop("policies", None) - if _policies is None: - _policies = [ - policies.RequestIdPolicy(**kwargs), - self._config.headers_policy, - self._config.user_agent_policy, - self._config.proxy_policy, - policies.ContentDecodePolicy(**kwargs), - ARMAutoResourceProviderRegistrationPolicy(), - self._config.redirect_policy, - self._config.retry_policy, - self._config.authentication_policy, - self._config.custom_hook_policy, - self._config.logging_policy, - policies.DistributedTracingPolicy(**kwargs), - policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, - self._config.http_logging_policy, - ] - self._client: ARMPipelineClient = ARMPipelineClient(base_url=base_url, policies=_policies, **kwargs) - - client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} - self._serialize = Serializer(client_models) - self._deserialize = Deserializer(client_models) - self._serialize.client_side_validation = False - self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize, "2019-09-01") - self.private_endpoint_connections = PrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2019-09-01" - ) - self.private_link_resources = PrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2019-09-01" - ) - self.operations = Operations(self._client, self._config, self._serialize, self._deserialize, "2019-09-01") - self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize, "2019-09-01") - - def _send_request(self, request: HttpRequest, *, stream: bool = False, **kwargs: Any) -> HttpResponse: - """Runs the network request through the client's chained policies. - - >>> from azure.core.rest import HttpRequest - >>> request = HttpRequest("GET", "https://www.example.org/") - - >>> response = client._send_request(request) - - - For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request - - :param request: The network request you want to make. Required. - :type request: ~azure.core.rest.HttpRequest - :keyword bool stream: Whether the response payload will be streamed. Defaults to False. - :return: The response of your network call. Does not do error handling on your response. - :rtype: ~azure.core.rest.HttpResponse - """ - - request_copy = deepcopy(request) - request_copy.url = self._client.format_url(request_copy.url) - return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore - - def close(self) -> None: - self._client.close() - - def __enter__(self) -> Self: - self._client.__enter__() - return self - - def __exit__(self, *exc_details: Any) -> None: - self._client.__exit__(*exc_details) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/_metadata.json b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/_metadata.json deleted file mode 100644 index 3ff1c8adf4e1..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/_metadata.json +++ /dev/null @@ -1,114 +0,0 @@ -{ - "chosen_version": "2019-09-01", - "total_api_version_list": ["2019-09-01"], - "client": { - "name": "KeyVaultManagementClient", - "filename": "_key_vault_management_client", - "description": "The Azure management API provides a RESTful set of web services that interact with Azure Key Vault.", - "host_value": "\"https://management.azure.com\"", - "parameterized_host_template": null, - "azure_arm": true, - "has_public_lro_operations": true, - "client_side_validation": false, - "sync_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"sdkcore\": {\"azure.mgmt.core\": [\"ARMPipelineClient\"], \"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"ARMAutoResourceProviderRegistrationPolicy\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \".._serialization\": [\"Deserializer\", \"Serializer\"]}, \"stdlib\": {\"typing_extensions\": [\"Self\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}}", - "async_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"sdkcore\": {\"azure.mgmt.core\": [\"AsyncARMPipelineClient\"], \"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"AsyncARMAutoResourceProviderRegistrationPolicy\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \"..._serialization\": [\"Deserializer\", \"Serializer\"]}, \"stdlib\": {\"typing_extensions\": [\"Self\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"]}}}" - }, - "global_parameters": { - "sync": { - "credential": { - "signature": "credential: \"TokenCredential\",", - "description": "Credential needed for the client to connect to Azure. Required.", - "docstring_type": "~azure.core.credentials.TokenCredential", - "required": true, - "method_location": "positional" - }, - "subscription_id": { - "signature": "subscription_id: str,", - "description": "Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. Required.", - "docstring_type": "str", - "required": true, - "method_location": "positional" - } - }, - "async": { - "credential": { - "signature": "credential: \"AsyncTokenCredential\",", - "description": "Credential needed for the client to connect to Azure. Required.", - "docstring_type": "~azure.core.credentials_async.AsyncTokenCredential", - "required": true - }, - "subscription_id": { - "signature": "subscription_id: str,", - "description": "Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. Required.", - "docstring_type": "str", - "required": true - } - }, - "constant": { - }, - "call": "credential, subscription_id", - "service_client_specific": { - "sync": { - "api_version": { - "signature": "api_version: Optional[str]=None,", - "description": "API version to use if no profile is provided, or if missing in profile.", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "base_url": { - "signature": "base_url: str = \"https://management.azure.com\",", - "description": "Service URL", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "profile": { - "signature": "profile: KnownProfiles=KnownProfiles.default,", - "description": "A profile definition, from KnownProfiles to dict.", - "docstring_type": "azure.profiles.KnownProfiles", - "required": false, - "method_location": "positional" - } - }, - "async": { - "api_version": { - "signature": "api_version: Optional[str] = None,", - "description": "API version to use if no profile is provided, or if missing in profile.", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "base_url": { - "signature": "base_url: str = \"https://management.azure.com\",", - "description": "Service URL", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "profile": { - "signature": "profile: KnownProfiles = KnownProfiles.default,", - "description": "A profile definition, from KnownProfiles to dict.", - "docstring_type": "azure.profiles.KnownProfiles", - "required": false, - "method_location": "positional" - } - } - } - }, - "config": { - "credential": true, - "credential_scopes": ["https://management.azure.com/.default"], - "credential_call_sync": "ARMChallengeAuthenticationPolicy(self.credential, *self.credential_scopes, **kwargs)", - "credential_call_async": "AsyncARMChallengeAuthenticationPolicy(self.credential, *self.credential_scopes, **kwargs)", - "sync_imports": "{\"regular\": {\"sdkcore\": {\"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"ARMChallengeAuthenticationPolicy\", \"ARMHttpLoggingPolicy\"]}, \"local\": {\"._version\": [\"VERSION\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}}", - "async_imports": "{\"regular\": {\"sdkcore\": {\"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"ARMHttpLoggingPolicy\", \"AsyncARMChallengeAuthenticationPolicy\"]}, \"local\": {\".._version\": [\"VERSION\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"]}}}" - }, - "operation_groups": { - "vaults": "VaultsOperations", - "private_endpoint_connections": "PrivateEndpointConnectionsOperations", - "private_link_resources": "PrivateLinkResourcesOperations", - "operations": "Operations", - "keys": "KeysOperations" - } -} diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/__init__.py deleted file mode 100644 index 6ba0c5a05353..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/__init__.py +++ /dev/null @@ -1,23 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._key_vault_management_client import KeyVaultManagementClient - -try: - from ._patch import __all__ as _patch_all - from ._patch import * # pylint: disable=unused-wildcard-import -except ImportError: - _patch_all = [] -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "KeyVaultManagementClient", -] -__all__.extend([p for p in _patch_all if p not in __all__]) - -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/_configuration.py deleted file mode 100644 index 8524844e2996..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/_configuration.py +++ /dev/null @@ -1,66 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from typing import Any, TYPE_CHECKING - -from azure.core.pipeline import policies -from azure.mgmt.core.policies import ARMHttpLoggingPolicy, AsyncARMChallengeAuthenticationPolicy - -from .._version import VERSION - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials_async import AsyncTokenCredential - - -class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long - """Configuration for KeyVaultManagementClient. - - Note that all parameters used to create this instance are saved as instance - attributes. - - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials_async.AsyncTokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :keyword api_version: Api Version. Default value is "2019-09-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str - """ - - def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None: - api_version: str = kwargs.pop("api_version", "2019-09-01") - - if credential is None: - raise ValueError("Parameter 'credential' must not be None.") - if subscription_id is None: - raise ValueError("Parameter 'subscription_id' must not be None.") - - self.credential = credential - self.subscription_id = subscription_id - self.api_version = api_version - self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) - kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) - self.polling_interval = kwargs.get("polling_interval", 30) - self._configure(**kwargs) - - def _configure(self, **kwargs: Any) -> None: - 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.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**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) - self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) - self.authentication_policy = kwargs.get("authentication_policy") - if self.credential and not self.authentication_policy: - self.authentication_policy = AsyncARMChallengeAuthenticationPolicy( - self.credential, *self.credential_scopes, **kwargs - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/_key_vault_management_client.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/_key_vault_management_client.py deleted file mode 100644 index db5a6d7417c1..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/_key_vault_management_client.py +++ /dev/null @@ -1,140 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from copy import deepcopy -from typing import Any, Awaitable, TYPE_CHECKING -from typing_extensions import Self - -from azure.core.pipeline import policies -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.mgmt.core import AsyncARMPipelineClient -from azure.mgmt.core.policies import AsyncARMAutoResourceProviderRegistrationPolicy - -from .. import models as _models -from ..._serialization import Deserializer, Serializer -from ._configuration import KeyVaultManagementClientConfiguration -from .operations import ( - KeysOperations, - Operations, - PrivateEndpointConnectionsOperations, - PrivateLinkResourcesOperations, - VaultsOperations, -) - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials_async import AsyncTokenCredential - - -class KeyVaultManagementClient: # pylint: disable=client-accepts-api-version-keyword - """The Azure management API provides a RESTful set of web services that interact with Azure Key - Vault. - - :ivar vaults: VaultsOperations operations - :vartype vaults: azure.mgmt.keyvault.v2019_09_01.aio.operations.VaultsOperations - :ivar private_endpoint_connections: PrivateEndpointConnectionsOperations operations - :vartype private_endpoint_connections: - azure.mgmt.keyvault.v2019_09_01.aio.operations.PrivateEndpointConnectionsOperations - :ivar private_link_resources: PrivateLinkResourcesOperations operations - :vartype private_link_resources: - azure.mgmt.keyvault.v2019_09_01.aio.operations.PrivateLinkResourcesOperations - :ivar operations: Operations operations - :vartype operations: azure.mgmt.keyvault.v2019_09_01.aio.operations.Operations - :ivar keys: KeysOperations operations - :vartype keys: azure.mgmt.keyvault.v2019_09_01.aio.operations.KeysOperations - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials_async.AsyncTokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :param base_url: Service URL. Default value is "https://management.azure.com". - :type base_url: str - :keyword api_version: Api Version. Default value is "2019-09-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. - """ - - def __init__( - self, - credential: "AsyncTokenCredential", - subscription_id: str, - base_url: str = "https://management.azure.com", - **kwargs: Any - ) -> None: - self._config = KeyVaultManagementClientConfiguration( - credential=credential, subscription_id=subscription_id, **kwargs - ) - _policies = kwargs.pop("policies", None) - if _policies is None: - _policies = [ - policies.RequestIdPolicy(**kwargs), - self._config.headers_policy, - self._config.user_agent_policy, - self._config.proxy_policy, - policies.ContentDecodePolicy(**kwargs), - AsyncARMAutoResourceProviderRegistrationPolicy(), - self._config.redirect_policy, - self._config.retry_policy, - self._config.authentication_policy, - self._config.custom_hook_policy, - self._config.logging_policy, - policies.DistributedTracingPolicy(**kwargs), - policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, - self._config.http_logging_policy, - ] - self._client: AsyncARMPipelineClient = AsyncARMPipelineClient(base_url=base_url, policies=_policies, **kwargs) - - client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} - self._serialize = Serializer(client_models) - self._deserialize = Deserializer(client_models) - self._serialize.client_side_validation = False - self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize, "2019-09-01") - self.private_endpoint_connections = PrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2019-09-01" - ) - self.private_link_resources = PrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2019-09-01" - ) - self.operations = Operations(self._client, self._config, self._serialize, self._deserialize, "2019-09-01") - self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize, "2019-09-01") - - def _send_request( - self, request: HttpRequest, *, stream: bool = False, **kwargs: Any - ) -> Awaitable[AsyncHttpResponse]: - """Runs the network request through the client's chained policies. - - >>> from azure.core.rest import HttpRequest - >>> request = HttpRequest("GET", "https://www.example.org/") - - >>> response = await client._send_request(request) - - - For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request - - :param request: The network request you want to make. Required. - :type request: ~azure.core.rest.HttpRequest - :keyword bool stream: Whether the response payload will be streamed. Defaults to False. - :return: The response of your network call. Does not do error handling on your response. - :rtype: ~azure.core.rest.AsyncHttpResponse - """ - - request_copy = deepcopy(request) - request_copy.url = self._client.format_url(request_copy.url) - return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore - - async def close(self) -> None: - await self._client.close() - - async def __aenter__(self) -> Self: - await self._client.__aenter__() - return self - - async def __aexit__(self, *exc_details: Any) -> None: - await self._client.__aexit__(*exc_details) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/operations/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/operations/__init__.py deleted file mode 100644 index d2cbc6d10784..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/operations/__init__.py +++ /dev/null @@ -1,27 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._vaults_operations import VaultsOperations -from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations -from ._private_link_resources_operations import PrivateLinkResourcesOperations -from ._operations import Operations -from ._keys_operations import KeysOperations - -from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "VaultsOperations", - "PrivateEndpointConnectionsOperations", - "PrivateLinkResourcesOperations", - "Operations", - "KeysOperations", -] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/operations/_keys_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/operations/_keys_operations.py deleted file mode 100644 index 5a610ee46932..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/operations/_keys_operations.py +++ /dev/null @@ -1,501 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, Type, TypeVar, Union, overload -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._keys_operations import ( - build_create_if_not_exist_request, - build_get_request, - build_get_version_request, - build_list_request, - build_list_versions_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class KeysOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2019_09_01.aio.KeyVaultManagementClient`'s - :attr:`keys` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @overload - async def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: _models.KeyCreateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Required. - :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.KeyCreateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: Union[_models.KeyCreateParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Is either a - KeyCreateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.KeyCreateParameters or IO[bytes] - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "KeyCreateParameters") - - _request = build_create_if_not_exist_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def get(self, resource_group_name: str, vault_name: str, key_name: str, **kwargs: Any) -> _models.Key: - """Gets the current version of the specified key from the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key to be retrieved. Required. - :type vault_name: str - :param key_name: The name of the key to be retrieved. Required. - :type key_name: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> AsyncIterable["_models.Key"]: - """Lists the keys in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the keys to be retrieved. Required. - :type vault_name: str - :return: An iterator like instance of either Key or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.Key] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("KeyListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace_async - async def get_version( - self, resource_group_name: str, vault_name: str, key_name: str, key_version: str, **kwargs: Any - ) -> _models.Key: - """Gets the specified version of the specified key in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key version to be retrieved. - Required. - :type vault_name: str - :param key_name: The name of the key version to be retrieved. Required. - :type key_name: str - :param key_version: The version of the key to be retrieved. Required. - :type key_version: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - _request = build_get_version_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - key_version=key_version, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_versions( - self, resource_group_name: str, vault_name: str, key_name: str, **kwargs: Any - ) -> AsyncIterable["_models.Key"]: - """Lists the versions of the specified key in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key versions to be retrieved. - Required. - :type vault_name: str - :param key_name: The name of the key versions to be retrieved. Required. - :type key_name: str - :return: An iterator like instance of either Key or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.Key] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_versions_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("KeyListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/operations/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/operations/_patch.py deleted file mode 100644 index 9b4f32f151b7..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/operations/_patch.py +++ /dev/null @@ -1,136 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -import sys -from typing import AsyncIterable, Any, Optional, List, Type -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ._vaults_operations import VaultsOperations as _VaultsOperations, ClsType -from ...operations._vaults_operations import build_list_request - -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports - -class VaultsOperations(_VaultsOperations): - - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - -__all__: List[str] = ["VaultsOperations"] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/operations/_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/operations/_private_endpoint_connections_operations.py deleted file mode 100644 index c408816451a4..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/operations/_private_endpoint_connections_operations.py +++ /dev/null @@ -1,393 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterator, Callable, Dict, IO, Optional, Type, TypeVar, Union, cast, overload - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._private_endpoint_connections_operations import ( - build_delete_request, - build_get_request, - build_put_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class PrivateEndpointConnectionsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2019_09_01.aio.KeyVaultManagementClient`'s - :attr:`private_endpoint_connections` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace_async - async def get( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Optional[_models.PrivateEndpointConnection]: - """Gets the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: PrivateEndpointConnection or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection or None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[Optional[_models.PrivateEndpointConnection]] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: _models.PrivateEndpointConnection, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: Union[_models.PrivateEndpointConnection, IO[bytes]], - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Is either a - PrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection or - IO[bytes] - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _json = self._serialize.body(properties, "PrivateEndpointConnection") - - _request = build_put_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Azure-AsyncOperation"] = self._deserialize( - "str", response.headers.get("Azure-AsyncOperation") - ) - - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - async def _delete_initial( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_delete( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> AsyncLROPoller[_models.PrivateEndpointConnection]: - """Deletes the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: An instance of AsyncLROPoller that returns either PrivateEndpointConnection or the - result of cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._delete_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.PrivateEndpointConnection].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.PrivateEndpointConnection]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/operations/_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/operations/_private_link_resources_operations.py deleted file mode 100644 index 83025885917e..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/operations/_private_link_resources_operations.py +++ /dev/null @@ -1,111 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._private_link_resources_operations import build_list_by_vault_request - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class PrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2019_09_01.aio.KeyVaultManagementClient`'s - :attr:`private_link_resources` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace_async - async def list_by_vault( - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> _models.PrivateLinkResourceListResult: - """Gets the private link resources supported for the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :return: PrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateLinkResourceListResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.PrivateLinkResourceListResult] = kwargs.pop("cls", None) - - _request = build_list_by_vault_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/operations/_vaults_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/operations/_vaults_operations.py deleted file mode 100644 index 9a7cdde5c242..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/operations/_vaults_operations.py +++ /dev/null @@ -1,1244 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import ( - Any, - AsyncIterable, - AsyncIterator, - Callable, - Dict, - IO, - Literal, - Optional, - Type, - TypeVar, - Union, - cast, - overload, -) -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._vaults_operations import ( - build_check_name_availability_request, - build_create_or_update_request, - build_delete_request, - build_get_deleted_request, - build_get_request, - build_list_by_resource_group_request, - build_list_by_subscription_request, - build_list_deleted_request, - build_list_request, - build_purge_deleted_request, - build_update_access_policy_request, - build_update_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class VaultsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2019_09_01.aio.KeyVaultManagementClient`'s - :attr:`vaults` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - async def _create_or_update_initial( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 201: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.VaultCreateOrUpdateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2019_09_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2019_09_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> AsyncLROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Is either a - VaultCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.VaultCreateOrUpdateParameters or - IO[bytes] - :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2019_09_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._create_or_update_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("Vault", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.Vault].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.Vault]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @overload - async def update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultPatchParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.VaultPatchParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultPatchParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Is either a VaultPatchParameters type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.VaultPatchParameters or IO[bytes] - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultPatchParameters") - - _request = build_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def delete( # pylint: disable=inconsistent-return-statements - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> None: - """Deletes the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault to delete. Required. - :type vault_name: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - @distributed_trace_async - async def get(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> _models.Vault: - """Gets the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: _models.VaultAccessPolicyParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2019_09_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.VaultAccessPolicyParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2019_09_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: Union[_models.VaultAccessPolicyParameters, IO[bytes]], - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2019_09_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Is either a - VaultAccessPolicyParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.VaultAccessPolicyParameters or - IO[bytes] - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.VaultAccessPolicyParameters] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") - - _request = build_update_access_policy_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - operation_kind=operation_kind, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription and - within the specified resource group. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedVault"]: - """Gets information about the deleted vaults in a subscription. - - :return: An iterator like instance of either DeletedVault or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.DeletedVault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.DeletedVaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("DeletedVaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace_async - async def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _models.DeletedVault: - """Gets the deleted Azure key vault. - - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param location: The location of the deleted vault. Required. - :type location: str - :return: DeletedVault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.DeletedVault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.DeletedVault] = kwargs.pop("cls", None) - - _request = build_get_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("DeletedVault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - async def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_purge_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_purge_deleted(self, vault_name: str, location: str, **kwargs: Any) -> AsyncLROPoller[None]: - """Permanently deletes the specified vault. aka Purges the deleted Azure key vault. - - :param vault_name: The name of the soft-deleted vault. Required. - :type vault_name: str - :param location: The location of the soft-deleted vault. Required. - :type location: str - :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._purge_deleted_initial( - vault_name=vault_name, - location=location, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @overload - async def check_name_availability( - self, - vault_name: _models.VaultCheckNameAvailabilityParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: ~azure.mgmt.keyvault.v2019_09_01.models.VaultCheckNameAvailabilityParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def check_name_availability( - self, vault_name: IO[bytes], *, content_type: str = "application/json", **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def check_name_availability( - self, vault_name: Union[_models.VaultCheckNameAvailabilityParameters, IO[bytes]], **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Is either a VaultCheckNameAvailabilityParameters type - or a IO[bytes] type. Required. - :type vault_name: ~azure.mgmt.keyvault.v2019_09_01.models.VaultCheckNameAvailabilityParameters - or IO[bytes] - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.CheckNameAvailabilityResult] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(vault_name, (IOBase, bytes)): - _content = vault_name - else: - _json = self._serialize.body(vault_name, "VaultCheckNameAvailabilityParameters") - - _request = build_check_name_availability_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/models/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/models/__init__.py deleted file mode 100644 index d69986848e28..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/models/__init__.py +++ /dev/null @@ -1,135 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._models_py3 import AccessPolicyEntry -from ._models_py3 import Attributes -from ._models_py3 import CheckNameAvailabilityResult -from ._models_py3 import CloudErrorBody -from ._models_py3 import DeletedVault -from ._models_py3 import DeletedVaultListResult -from ._models_py3 import DeletedVaultProperties -from ._models_py3 import DimensionProperties -from ._models_py3 import IPRule -from ._models_py3 import Key -from ._models_py3 import KeyAttributes -from ._models_py3 import KeyCreateParameters -from ._models_py3 import KeyListResult -from ._models_py3 import KeyProperties -from ._models_py3 import LogSpecification -from ._models_py3 import MetricSpecification -from ._models_py3 import NetworkRuleSet -from ._models_py3 import Operation -from ._models_py3 import OperationDisplay -from ._models_py3 import OperationListResult -from ._models_py3 import Permissions -from ._models_py3 import PrivateEndpoint -from ._models_py3 import PrivateEndpointConnection -from ._models_py3 import PrivateEndpointConnectionItem -from ._models_py3 import PrivateLinkResource -from ._models_py3 import PrivateLinkResourceListResult -from ._models_py3 import PrivateLinkServiceConnectionState -from ._models_py3 import Resource -from ._models_py3 import ResourceListResult -from ._models_py3 import ServiceSpecification -from ._models_py3 import Sku -from ._models_py3 import Vault -from ._models_py3 import VaultAccessPolicyParameters -from ._models_py3 import VaultAccessPolicyProperties -from ._models_py3 import VaultCheckNameAvailabilityParameters -from ._models_py3 import VaultCreateOrUpdateParameters -from ._models_py3 import VaultListResult -from ._models_py3 import VaultPatchParameters -from ._models_py3 import VaultPatchProperties -from ._models_py3 import VaultProperties -from ._models_py3 import VirtualNetworkRule - -from ._key_vault_management_client_enums import AccessPolicyUpdateKind -from ._key_vault_management_client_enums import CertificatePermissions -from ._key_vault_management_client_enums import CreateMode -from ._key_vault_management_client_enums import DeletionRecoveryLevel -from ._key_vault_management_client_enums import JsonWebKeyCurveName -from ._key_vault_management_client_enums import JsonWebKeyOperation -from ._key_vault_management_client_enums import JsonWebKeyType -from ._key_vault_management_client_enums import KeyPermissions -from ._key_vault_management_client_enums import NetworkRuleAction -from ._key_vault_management_client_enums import NetworkRuleBypassOptions -from ._key_vault_management_client_enums import PrivateEndpointConnectionProvisioningState -from ._key_vault_management_client_enums import PrivateEndpointServiceConnectionStatus -from ._key_vault_management_client_enums import Reason -from ._key_vault_management_client_enums import SecretPermissions -from ._key_vault_management_client_enums import SkuFamily -from ._key_vault_management_client_enums import SkuName -from ._key_vault_management_client_enums import StoragePermissions -from ._key_vault_management_client_enums import VaultProvisioningState -from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "AccessPolicyEntry", - "Attributes", - "CheckNameAvailabilityResult", - "CloudErrorBody", - "DeletedVault", - "DeletedVaultListResult", - "DeletedVaultProperties", - "DimensionProperties", - "IPRule", - "Key", - "KeyAttributes", - "KeyCreateParameters", - "KeyListResult", - "KeyProperties", - "LogSpecification", - "MetricSpecification", - "NetworkRuleSet", - "Operation", - "OperationDisplay", - "OperationListResult", - "Permissions", - "PrivateEndpoint", - "PrivateEndpointConnection", - "PrivateEndpointConnectionItem", - "PrivateLinkResource", - "PrivateLinkResourceListResult", - "PrivateLinkServiceConnectionState", - "Resource", - "ResourceListResult", - "ServiceSpecification", - "Sku", - "Vault", - "VaultAccessPolicyParameters", - "VaultAccessPolicyProperties", - "VaultCheckNameAvailabilityParameters", - "VaultCreateOrUpdateParameters", - "VaultListResult", - "VaultPatchParameters", - "VaultPatchProperties", - "VaultProperties", - "VirtualNetworkRule", - "AccessPolicyUpdateKind", - "CertificatePermissions", - "CreateMode", - "DeletionRecoveryLevel", - "JsonWebKeyCurveName", - "JsonWebKeyOperation", - "JsonWebKeyType", - "KeyPermissions", - "NetworkRuleAction", - "NetworkRuleBypassOptions", - "PrivateEndpointConnectionProvisioningState", - "PrivateEndpointServiceConnectionStatus", - "Reason", - "SecretPermissions", - "SkuFamily", - "SkuName", - "StoragePermissions", - "VaultProvisioningState", -] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/models/_key_vault_management_client_enums.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/models/_key_vault_management_client_enums.py deleted file mode 100644 index 6e7b5330a217..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/models/_key_vault_management_client_enums.py +++ /dev/null @@ -1,217 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from enum import Enum -from azure.core import CaseInsensitiveEnumMeta - - -class AccessPolicyUpdateKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """AccessPolicyUpdateKind.""" - - ADD = "add" - REPLACE = "replace" - REMOVE = "remove" - - -class CertificatePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """CertificatePermissions.""" - - ALL = "all" - GET = "get" - LIST = "list" - DELETE = "delete" - CREATE = "create" - IMPORT = "import" - UPDATE = "update" - MANAGECONTACTS = "managecontacts" - GETISSUERS = "getissuers" - LISTISSUERS = "listissuers" - SETISSUERS = "setissuers" - DELETEISSUERS = "deleteissuers" - MANAGEISSUERS = "manageissuers" - RECOVER = "recover" - PURGE = "purge" - BACKUP = "backup" - RESTORE = "restore" - IMPORT_ENUM = "import" - - -class CreateMode(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The vault's create mode to indicate whether the vault need to be recovered or not.""" - - RECOVER = "recover" - DEFAULT = "default" - - -class DeletionRecoveryLevel(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The deletion recovery level currently in effect for the object. If it contains 'Purgeable', - then the object can be permanently deleted by a privileged user; otherwise, only the system can - purge the object at the end of the retention interval. - """ - - PURGEABLE = "Purgeable" - RECOVERABLE_PURGEABLE = "Recoverable+Purgeable" - RECOVERABLE = "Recoverable" - RECOVERABLE_PROTECTED_SUBSCRIPTION = "Recoverable+ProtectedSubscription" - - -class JsonWebKeyCurveName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The elliptic curve name. For valid values, see JsonWebKeyCurveName.""" - - P256 = "P-256" - P384 = "P-384" - P521 = "P-521" - P256_K = "P-256K" - - -class JsonWebKeyOperation(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The permitted JSON web key operations of the key. For more information, see - JsonWebKeyOperation. - """ - - ENCRYPT = "encrypt" - DECRYPT = "decrypt" - SIGN = "sign" - VERIFY = "verify" - WRAP_KEY = "wrapKey" - UNWRAP_KEY = "unwrapKey" - IMPORT = "import" - IMPORT_ENUM = "import" - - -class JsonWebKeyType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of the key. For valid values, see JsonWebKeyType.""" - - EC = "EC" - EC_HSM = "EC-HSM" - RSA = "RSA" - RSA_HSM = "RSA-HSM" - - -class KeyPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """KeyPermissions.""" - - ALL = "all" - ENCRYPT = "encrypt" - DECRYPT = "decrypt" - WRAP_KEY = "wrapKey" - UNWRAP_KEY = "unwrapKey" - SIGN = "sign" - VERIFY = "verify" - GET = "get" - LIST = "list" - CREATE = "create" - UPDATE = "update" - IMPORT = "import" - DELETE = "delete" - BACKUP = "backup" - RESTORE = "restore" - RECOVER = "recover" - PURGE = "purge" - IMPORT_ENUM = "import" - - -class NetworkRuleAction(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The default action when no rule from ipRules and from virtualNetworkRules match. This is only - used after the bypass property has been evaluated. - """ - - ALLOW = "Allow" - DENY = "Deny" - - -class NetworkRuleBypassOptions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Tells what traffic can bypass network rules. This can be 'AzureServices' or 'None'. If not - specified the default is 'AzureServices'. - """ - - AZURE_SERVICES = "AzureServices" - NONE = "None" - - -class PrivateEndpointConnectionProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The current provisioning state.""" - - SUCCEEDED = "Succeeded" - CREATING = "Creating" - UPDATING = "Updating" - DELETING = "Deleting" - FAILED = "Failed" - DISCONNECTED = "Disconnected" - - -class PrivateEndpointServiceConnectionStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The private endpoint connection status.""" - - PENDING = "Pending" - APPROVED = "Approved" - REJECTED = "Rejected" - DISCONNECTED = "Disconnected" - - -class Reason(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The reason that a vault name could not be used. The Reason element is only returned if - NameAvailable is false. - """ - - ACCOUNT_NAME_INVALID = "AccountNameInvalid" - ALREADY_EXISTS = "AlreadyExists" - - -class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SecretPermissions.""" - - ALL = "all" - GET = "get" - LIST = "list" - SET = "set" - DELETE = "delete" - BACKUP = "backup" - RESTORE = "restore" - RECOVER = "recover" - PURGE = "purge" - - -class SkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU family name.""" - - A = "A" - - -class SkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU name to specify whether the key vault is a standard vault or a premium vault.""" - - STANDARD = "standard" - PREMIUM = "premium" - - -class StoragePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """StoragePermissions.""" - - ALL = "all" - GET = "get" - LIST = "list" - DELETE = "delete" - SET = "set" - UPDATE = "update" - REGENERATEKEY = "regeneratekey" - RECOVER = "recover" - PURGE = "purge" - BACKUP = "backup" - RESTORE = "restore" - SETSAS = "setsas" - LISTSAS = "listsas" - GETSAS = "getsas" - DELETESAS = "deletesas" - - -class VaultProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Provisioning state of the vault.""" - - SUCCEEDED = "Succeeded" - REGISTERING_DNS = "RegisteringDns" diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/models/_models_py3.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/models/_models_py3.py deleted file mode 100644 index 05f470487da4..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/models/_models_py3.py +++ /dev/null @@ -1,2080 +0,0 @@ -# coding=utf-8 -# pylint: disable=too-many-lines -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from typing import Any, Dict, List, Optional, TYPE_CHECKING, Union - -from ... import _serialization - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from .. import models as _models - - -class AccessPolicyEntry(_serialization.Model): - """An identity that have access to the key vault. All identities in the array must use the same - tenant ID as the key vault's tenant ID. - - All required parameters must be populated in order to send to server. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :vartype tenant_id: str - :ivar object_id: The object ID of a user, service principal or security group in the Azure - Active Directory tenant for the vault. The object ID must be unique for the list of access - policies. Required. - :vartype object_id: str - :ivar application_id: Application ID of the client making request on behalf of a principal. - :vartype application_id: str - :ivar permissions: Permissions the identity has for keys, secrets and certificates. Required. - :vartype permissions: ~azure.mgmt.keyvault.v2019_09_01.models.Permissions - """ - - _validation = { - "tenant_id": {"required": True}, - "object_id": {"required": True}, - "permissions": {"required": True}, - } - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "object_id": {"key": "objectId", "type": "str"}, - "application_id": {"key": "applicationId", "type": "str"}, - "permissions": {"key": "permissions", "type": "Permissions"}, - } - - def __init__( - self, - *, - tenant_id: str, - object_id: str, - permissions: "_models.Permissions", - application_id: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :paramtype tenant_id: str - :keyword object_id: The object ID of a user, service principal or security group in the Azure - Active Directory tenant for the vault. The object ID must be unique for the list of access - policies. Required. - :paramtype object_id: str - :keyword application_id: Application ID of the client making request on behalf of a principal. - :paramtype application_id: str - :keyword permissions: Permissions the identity has for keys, secrets and certificates. - Required. - :paramtype permissions: ~azure.mgmt.keyvault.v2019_09_01.models.Permissions - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.object_id = object_id - self.application_id = application_id - self.permissions = permissions - - -class Attributes(_serialization.Model): - """The object attributes managed by the Azure Key Vault service. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar enabled: Determines whether or not the object is enabled. - :vartype enabled: bool - :ivar not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :vartype not_before: int - :ivar expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :vartype expires: int - :ivar created: Creation time in seconds since 1970-01-01T00:00:00Z. - :vartype created: int - :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: int - :ivar recovery_level: The deletion recovery level currently in effect for the object. If it - contains 'Purgeable', then the object can be permanently deleted by a privileged user; - otherwise, only the system can purge the object at the end of the retention interval. Known - values are: "Purgeable", "Recoverable+Purgeable", "Recoverable", and - "Recoverable+ProtectedSubscription". - :vartype recovery_level: str or ~azure.mgmt.keyvault.v2019_09_01.models.DeletionRecoveryLevel - """ - - _validation = { - "created": {"readonly": True}, - "updated": {"readonly": True}, - "recovery_level": {"readonly": True}, - } - - _attribute_map = { - "enabled": {"key": "enabled", "type": "bool"}, - "not_before": {"key": "nbf", "type": "int"}, - "expires": {"key": "exp", "type": "int"}, - "created": {"key": "created", "type": "int"}, - "updated": {"key": "updated", "type": "int"}, - "recovery_level": {"key": "recoveryLevel", "type": "str"}, - } - - def __init__( - self, - *, - enabled: Optional[bool] = None, - not_before: Optional[int] = None, - expires: Optional[int] = None, - **kwargs: Any - ) -> None: - """ - :keyword enabled: Determines whether or not the object is enabled. - :paramtype enabled: bool - :keyword not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :paramtype not_before: int - :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :paramtype expires: int - """ - super().__init__(**kwargs) - self.enabled = enabled - self.not_before = not_before - self.expires = expires - self.created = None - self.updated = None - self.recovery_level = None - - -class CheckNameAvailabilityResult(_serialization.Model): - """The CheckNameAvailability operation response. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar name_available: A boolean value that indicates whether the name is available for you to - use. If true, the name is available. If false, the name has already been taken or is invalid - and cannot be used. - :vartype name_available: bool - :ivar reason: The reason that a vault name could not be used. The Reason element is only - returned if NameAvailable is false. Known values are: "AccountNameInvalid" and "AlreadyExists". - :vartype reason: str or ~azure.mgmt.keyvault.v2019_09_01.models.Reason - :ivar message: An error message explaining the Reason value in more detail. - :vartype message: str - """ - - _validation = { - "name_available": {"readonly": True}, - "reason": {"readonly": True}, - "message": {"readonly": True}, - } - - _attribute_map = { - "name_available": {"key": "nameAvailable", "type": "bool"}, - "reason": {"key": "reason", "type": "str"}, - "message": {"key": "message", "type": "str"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.name_available = None - self.reason = None - self.message = None - - -class CloudErrorBody(_serialization.Model): - """An error response from Key Vault resource provider. - - :ivar code: Error code. This is a mnemonic that can be consumed programmatically. - :vartype code: str - :ivar message: User friendly error message. The message is typically localized and may vary - with service version. - :vartype message: str - """ - - _attribute_map = { - "code": {"key": "code", "type": "str"}, - "message": {"key": "message", "type": "str"}, - } - - def __init__(self, *, code: Optional[str] = None, message: Optional[str] = None, **kwargs: Any) -> None: - """ - :keyword code: Error code. This is a mnemonic that can be consumed programmatically. - :paramtype code: str - :keyword message: User friendly error message. The message is typically localized and may vary - with service version. - :paramtype message: str - """ - super().__init__(**kwargs) - self.code = code - self.message = message - - -class DeletedVault(_serialization.Model): - """Deleted vault information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The resource ID for the deleted key vault. - :vartype id: str - :ivar name: The name of the key vault. - :vartype name: str - :ivar type: The resource type of the key vault. - :vartype type: str - :ivar properties: Properties of the vault. - :vartype properties: ~azure.mgmt.keyvault.v2019_09_01.models.DeletedVaultProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "properties": {"key": "properties", "type": "DeletedVaultProperties"}, - } - - def __init__(self, *, properties: Optional["_models.DeletedVaultProperties"] = None, **kwargs: Any) -> None: - """ - :keyword properties: Properties of the vault. - :paramtype properties: ~azure.mgmt.keyvault.v2019_09_01.models.DeletedVaultProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.properties = properties - - -class DeletedVaultListResult(_serialization.Model): - """List of vaults. - - :ivar value: The list of deleted vaults. - :vartype value: list[~azure.mgmt.keyvault.v2019_09_01.models.DeletedVault] - :ivar next_link: The URL to get the next set of deleted vaults. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[DeletedVault]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.DeletedVault"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of deleted vaults. - :paramtype value: list[~azure.mgmt.keyvault.v2019_09_01.models.DeletedVault] - :keyword next_link: The URL to get the next set of deleted vaults. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class DeletedVaultProperties(_serialization.Model): - """Properties of the deleted vault. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar vault_id: The resource id of the original vault. - :vartype vault_id: str - :ivar location: The location of the original vault. - :vartype location: str - :ivar deletion_date: The deleted date. - :vartype deletion_date: ~datetime.datetime - :ivar scheduled_purge_date: The scheduled purged date. - :vartype scheduled_purge_date: ~datetime.datetime - :ivar tags: Tags of the original vault. - :vartype tags: dict[str, str] - :ivar purge_protection_enabled: Purge protection status of the original vault. - :vartype purge_protection_enabled: bool - """ - - _validation = { - "vault_id": {"readonly": True}, - "location": {"readonly": True}, - "deletion_date": {"readonly": True}, - "scheduled_purge_date": {"readonly": True}, - "tags": {"readonly": True}, - "purge_protection_enabled": {"readonly": True}, - } - - _attribute_map = { - "vault_id": {"key": "vaultId", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "deletion_date": {"key": "deletionDate", "type": "iso-8601"}, - "scheduled_purge_date": {"key": "scheduledPurgeDate", "type": "iso-8601"}, - "tags": {"key": "tags", "type": "{str}"}, - "purge_protection_enabled": {"key": "purgeProtectionEnabled", "type": "bool"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.vault_id = None - self.location = None - self.deletion_date = None - self.scheduled_purge_date = None - self.tags = None - self.purge_protection_enabled = None - - -class DimensionProperties(_serialization.Model): - """Type of operation: get, read, delete, etc. - - :ivar name: Name of dimension. - :vartype name: str - :ivar display_name: Display name of dimension. - :vartype display_name: str - :ivar to_be_exported_for_shoebox: Property to specify whether the dimension should be exported - for shoebox. - :vartype to_be_exported_for_shoebox: bool - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display_name": {"key": "displayName", "type": "str"}, - "to_be_exported_for_shoebox": {"key": "toBeExportedForShoebox", "type": "bool"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display_name: Optional[str] = None, - to_be_exported_for_shoebox: Optional[bool] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Name of dimension. - :paramtype name: str - :keyword display_name: Display name of dimension. - :paramtype display_name: str - :keyword to_be_exported_for_shoebox: Property to specify whether the dimension should be - exported for shoebox. - :paramtype to_be_exported_for_shoebox: bool - """ - super().__init__(**kwargs) - self.name = name - self.display_name = display_name - self.to_be_exported_for_shoebox = to_be_exported_for_shoebox - - -class IPRule(_serialization.Model): - """A rule governing the accessibility of a vault from a specific ip address or ip range. - - All required parameters must be populated in order to send to server. - - :ivar value: An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP address) - or '124.56.78.0/24' (all addresses that start with 124.56.78). Required. - :vartype value: str - """ - - _validation = { - "value": {"required": True}, - } - - _attribute_map = { - "value": {"key": "value", "type": "str"}, - } - - def __init__(self, *, value: str, **kwargs: Any) -> None: - """ - :keyword value: An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP - address) or '124.56.78.0/24' (all addresses that start with 124.56.78). Required. - :paramtype value: str - """ - super().__init__(**kwargs) - self.value = value - - -class Resource(_serialization.Model): - """Key Vault resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = None - self.tags = None - - -class Key(Resource): # pylint: disable=too-many-instance-attributes - """The key resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar attributes: The attributes of the key. - :vartype attributes: ~azure.mgmt.keyvault.v2019_09_01.models.KeyAttributes - :ivar kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: "EC", - "EC-HSM", "RSA", and "RSA-HSM". - :vartype kty: str or ~azure.mgmt.keyvault.v2019_09_01.models.JsonWebKeyType - :ivar key_ops: - :vartype key_ops: list[str or ~azure.mgmt.keyvault.v2019_09_01.models.JsonWebKeyOperation] - :ivar key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. - :vartype key_size: int - :ivar curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :vartype curve_name: str or ~azure.mgmt.keyvault.v2019_09_01.models.JsonWebKeyCurveName - :ivar key_uri: The URI to retrieve the current version of the key. - :vartype key_uri: str - :ivar key_uri_with_version: The URI to retrieve the specific version of the key. - :vartype key_uri_with_version: str - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - "key_uri": {"readonly": True}, - "key_uri_with_version": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "attributes": {"key": "properties.attributes", "type": "KeyAttributes"}, - "kty": {"key": "properties.kty", "type": "str"}, - "key_ops": {"key": "properties.keyOps", "type": "[str]"}, - "key_size": {"key": "properties.keySize", "type": "int"}, - "curve_name": {"key": "properties.curveName", "type": "str"}, - "key_uri": {"key": "properties.keyUri", "type": "str"}, - "key_uri_with_version": {"key": "properties.keyUriWithVersion", "type": "str"}, - } - - def __init__( - self, - *, - attributes: Optional["_models.KeyAttributes"] = None, - kty: Optional[Union[str, "_models.JsonWebKeyType"]] = None, - key_ops: Optional[List[Union[str, "_models.JsonWebKeyOperation"]]] = None, - key_size: Optional[int] = None, - curve_name: Optional[Union[str, "_models.JsonWebKeyCurveName"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword attributes: The attributes of the key. - :paramtype attributes: ~azure.mgmt.keyvault.v2019_09_01.models.KeyAttributes - :keyword kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: - "EC", "EC-HSM", "RSA", and "RSA-HSM". - :paramtype kty: str or ~azure.mgmt.keyvault.v2019_09_01.models.JsonWebKeyType - :keyword key_ops: - :paramtype key_ops: list[str or ~azure.mgmt.keyvault.v2019_09_01.models.JsonWebKeyOperation] - :keyword key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. - :paramtype key_size: int - :keyword curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :paramtype curve_name: str or ~azure.mgmt.keyvault.v2019_09_01.models.JsonWebKeyCurveName - """ - super().__init__(**kwargs) - self.attributes = attributes - self.kty = kty - self.key_ops = key_ops - self.key_size = key_size - self.curve_name = curve_name - self.key_uri = None - self.key_uri_with_version = None - - -class KeyAttributes(Attributes): - """The attributes of the key. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar enabled: Determines whether or not the object is enabled. - :vartype enabled: bool - :ivar not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :vartype not_before: int - :ivar expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :vartype expires: int - :ivar created: Creation time in seconds since 1970-01-01T00:00:00Z. - :vartype created: int - :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: int - :ivar recovery_level: The deletion recovery level currently in effect for the object. If it - contains 'Purgeable', then the object can be permanently deleted by a privileged user; - otherwise, only the system can purge the object at the end of the retention interval. Known - values are: "Purgeable", "Recoverable+Purgeable", "Recoverable", and - "Recoverable+ProtectedSubscription". - :vartype recovery_level: str or ~azure.mgmt.keyvault.v2019_09_01.models.DeletionRecoveryLevel - """ - - -class KeyCreateParameters(_serialization.Model): - """The parameters used to create a key. - - All required parameters must be populated in order to send to server. - - :ivar tags: The tags that will be assigned to the key. - :vartype tags: dict[str, str] - :ivar properties: The properties of the key to be created. Required. - :vartype properties: ~azure.mgmt.keyvault.v2019_09_01.models.KeyProperties - """ - - _validation = { - "properties": {"required": True}, - } - - _attribute_map = { - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "KeyProperties"}, - } - - def __init__( - self, *, properties: "_models.KeyProperties", tags: Optional[Dict[str, str]] = None, **kwargs: Any - ) -> None: - """ - :keyword tags: The tags that will be assigned to the key. - :paramtype tags: dict[str, str] - :keyword properties: The properties of the key to be created. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2019_09_01.models.KeyProperties - """ - super().__init__(**kwargs) - self.tags = tags - self.properties = properties - - -class KeyListResult(_serialization.Model): - """The page of keys. - - :ivar value: The key resources. - :vartype value: list[~azure.mgmt.keyvault.v2019_09_01.models.Key] - :ivar next_link: The URL to get the next page of keys. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Key]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Key"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The key resources. - :paramtype value: list[~azure.mgmt.keyvault.v2019_09_01.models.Key] - :keyword next_link: The URL to get the next page of keys. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class KeyProperties(_serialization.Model): - """The properties of the key. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar attributes: The attributes of the key. - :vartype attributes: ~azure.mgmt.keyvault.v2019_09_01.models.KeyAttributes - :ivar kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: "EC", - "EC-HSM", "RSA", and "RSA-HSM". - :vartype kty: str or ~azure.mgmt.keyvault.v2019_09_01.models.JsonWebKeyType - :ivar key_ops: - :vartype key_ops: list[str or ~azure.mgmt.keyvault.v2019_09_01.models.JsonWebKeyOperation] - :ivar key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. - :vartype key_size: int - :ivar curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :vartype curve_name: str or ~azure.mgmt.keyvault.v2019_09_01.models.JsonWebKeyCurveName - :ivar key_uri: The URI to retrieve the current version of the key. - :vartype key_uri: str - :ivar key_uri_with_version: The URI to retrieve the specific version of the key. - :vartype key_uri_with_version: str - """ - - _validation = { - "key_uri": {"readonly": True}, - "key_uri_with_version": {"readonly": True}, - } - - _attribute_map = { - "attributes": {"key": "attributes", "type": "KeyAttributes"}, - "kty": {"key": "kty", "type": "str"}, - "key_ops": {"key": "keyOps", "type": "[str]"}, - "key_size": {"key": "keySize", "type": "int"}, - "curve_name": {"key": "curveName", "type": "str"}, - "key_uri": {"key": "keyUri", "type": "str"}, - "key_uri_with_version": {"key": "keyUriWithVersion", "type": "str"}, - } - - def __init__( - self, - *, - attributes: Optional["_models.KeyAttributes"] = None, - kty: Optional[Union[str, "_models.JsonWebKeyType"]] = None, - key_ops: Optional[List[Union[str, "_models.JsonWebKeyOperation"]]] = None, - key_size: Optional[int] = None, - curve_name: Optional[Union[str, "_models.JsonWebKeyCurveName"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword attributes: The attributes of the key. - :paramtype attributes: ~azure.mgmt.keyvault.v2019_09_01.models.KeyAttributes - :keyword kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: - "EC", "EC-HSM", "RSA", and "RSA-HSM". - :paramtype kty: str or ~azure.mgmt.keyvault.v2019_09_01.models.JsonWebKeyType - :keyword key_ops: - :paramtype key_ops: list[str or ~azure.mgmt.keyvault.v2019_09_01.models.JsonWebKeyOperation] - :keyword key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. - :paramtype key_size: int - :keyword curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :paramtype curve_name: str or ~azure.mgmt.keyvault.v2019_09_01.models.JsonWebKeyCurveName - """ - super().__init__(**kwargs) - self.attributes = attributes - self.kty = kty - self.key_ops = key_ops - self.key_size = key_size - self.curve_name = curve_name - self.key_uri = None - self.key_uri_with_version = None - - -class LogSpecification(_serialization.Model): - """Log specification of operation. - - :ivar name: Name of log specification. - :vartype name: str - :ivar display_name: Display name of log specification. - :vartype display_name: str - :ivar blob_duration: Blob duration of specification. - :vartype blob_duration: str - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display_name": {"key": "displayName", "type": "str"}, - "blob_duration": {"key": "blobDuration", "type": "str"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display_name: Optional[str] = None, - blob_duration: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Name of log specification. - :paramtype name: str - :keyword display_name: Display name of log specification. - :paramtype display_name: str - :keyword blob_duration: Blob duration of specification. - :paramtype blob_duration: str - """ - super().__init__(**kwargs) - self.name = name - self.display_name = display_name - self.blob_duration = blob_duration - - -class MetricSpecification(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Metric specification of operation. - - :ivar name: Name of metric specification. - :vartype name: str - :ivar display_name: Display name of Metric specification. - :vartype display_name: str - :ivar display_description: Display description of Metric specification. - :vartype display_description: str - :ivar unit: The metric unit. Possible values include: 'Bytes', 'Count', 'Milliseconds'. - :vartype unit: str - :ivar aggregation_type: The metric aggregation type. Possible values include: 'Average', - 'Count', 'Total'. - :vartype aggregation_type: str - :ivar supported_aggregation_types: The supported aggregation types for the metrics. - :vartype supported_aggregation_types: list[str] - :ivar supported_time_grain_types: The supported time grain types for the metrics. - :vartype supported_time_grain_types: list[str] - :ivar lock_aggregation_type: The metric lock aggregation type. - :vartype lock_aggregation_type: str - :ivar dimensions: The dimensions of metric. - :vartype dimensions: list[~azure.mgmt.keyvault.v2019_09_01.models.DimensionProperties] - :ivar fill_gap_with_zero: Property to specify whether to fill gap with zero. - :vartype fill_gap_with_zero: bool - :ivar internal_metric_name: The internal metric name. - :vartype internal_metric_name: str - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display_name": {"key": "displayName", "type": "str"}, - "display_description": {"key": "displayDescription", "type": "str"}, - "unit": {"key": "unit", "type": "str"}, - "aggregation_type": {"key": "aggregationType", "type": "str"}, - "supported_aggregation_types": {"key": "supportedAggregationTypes", "type": "[str]"}, - "supported_time_grain_types": {"key": "supportedTimeGrainTypes", "type": "[str]"}, - "lock_aggregation_type": {"key": "lockAggregationType", "type": "str"}, - "dimensions": {"key": "dimensions", "type": "[DimensionProperties]"}, - "fill_gap_with_zero": {"key": "fillGapWithZero", "type": "bool"}, - "internal_metric_name": {"key": "internalMetricName", "type": "str"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display_name: Optional[str] = None, - display_description: Optional[str] = None, - unit: Optional[str] = None, - aggregation_type: Optional[str] = None, - supported_aggregation_types: Optional[List[str]] = None, - supported_time_grain_types: Optional[List[str]] = None, - lock_aggregation_type: Optional[str] = None, - dimensions: Optional[List["_models.DimensionProperties"]] = None, - fill_gap_with_zero: Optional[bool] = None, - internal_metric_name: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Name of metric specification. - :paramtype name: str - :keyword display_name: Display name of Metric specification. - :paramtype display_name: str - :keyword display_description: Display description of Metric specification. - :paramtype display_description: str - :keyword unit: The metric unit. Possible values include: 'Bytes', 'Count', 'Milliseconds'. - :paramtype unit: str - :keyword aggregation_type: The metric aggregation type. Possible values include: 'Average', - 'Count', 'Total'. - :paramtype aggregation_type: str - :keyword supported_aggregation_types: The supported aggregation types for the metrics. - :paramtype supported_aggregation_types: list[str] - :keyword supported_time_grain_types: The supported time grain types for the metrics. - :paramtype supported_time_grain_types: list[str] - :keyword lock_aggregation_type: The metric lock aggregation type. - :paramtype lock_aggregation_type: str - :keyword dimensions: The dimensions of metric. - :paramtype dimensions: list[~azure.mgmt.keyvault.v2019_09_01.models.DimensionProperties] - :keyword fill_gap_with_zero: Property to specify whether to fill gap with zero. - :paramtype fill_gap_with_zero: bool - :keyword internal_metric_name: The internal metric name. - :paramtype internal_metric_name: str - """ - super().__init__(**kwargs) - self.name = name - self.display_name = display_name - self.display_description = display_description - self.unit = unit - self.aggregation_type = aggregation_type - self.supported_aggregation_types = supported_aggregation_types - self.supported_time_grain_types = supported_time_grain_types - self.lock_aggregation_type = lock_aggregation_type - self.dimensions = dimensions - self.fill_gap_with_zero = fill_gap_with_zero - self.internal_metric_name = internal_metric_name - - -class NetworkRuleSet(_serialization.Model): - """A set of rules governing the network accessibility of a vault. - - :ivar bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or - 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and - "None". - :vartype bypass: str or ~azure.mgmt.keyvault.v2019_09_01.models.NetworkRuleBypassOptions - :ivar default_action: The default action when no rule from ipRules and from virtualNetworkRules - match. This is only used after the bypass property has been evaluated. Known values are: - "Allow" and "Deny". - :vartype default_action: str or ~azure.mgmt.keyvault.v2019_09_01.models.NetworkRuleAction - :ivar ip_rules: The list of IP address rules. - :vartype ip_rules: list[~azure.mgmt.keyvault.v2019_09_01.models.IPRule] - :ivar virtual_network_rules: The list of virtual network rules. - :vartype virtual_network_rules: - list[~azure.mgmt.keyvault.v2019_09_01.models.VirtualNetworkRule] - """ - - _attribute_map = { - "bypass": {"key": "bypass", "type": "str"}, - "default_action": {"key": "defaultAction", "type": "str"}, - "ip_rules": {"key": "ipRules", "type": "[IPRule]"}, - "virtual_network_rules": {"key": "virtualNetworkRules", "type": "[VirtualNetworkRule]"}, - } - - def __init__( - self, - *, - bypass: Optional[Union[str, "_models.NetworkRuleBypassOptions"]] = None, - default_action: Optional[Union[str, "_models.NetworkRuleAction"]] = None, - ip_rules: Optional[List["_models.IPRule"]] = None, - virtual_network_rules: Optional[List["_models.VirtualNetworkRule"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or - 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and - "None". - :paramtype bypass: str or ~azure.mgmt.keyvault.v2019_09_01.models.NetworkRuleBypassOptions - :keyword default_action: The default action when no rule from ipRules and from - virtualNetworkRules match. This is only used after the bypass property has been evaluated. - Known values are: "Allow" and "Deny". - :paramtype default_action: str or ~azure.mgmt.keyvault.v2019_09_01.models.NetworkRuleAction - :keyword ip_rules: The list of IP address rules. - :paramtype ip_rules: list[~azure.mgmt.keyvault.v2019_09_01.models.IPRule] - :keyword virtual_network_rules: The list of virtual network rules. - :paramtype virtual_network_rules: - list[~azure.mgmt.keyvault.v2019_09_01.models.VirtualNetworkRule] - """ - super().__init__(**kwargs) - self.bypass = bypass - self.default_action = default_action - self.ip_rules = ip_rules - self.virtual_network_rules = virtual_network_rules - - -class Operation(_serialization.Model): - """Key Vault REST API operation definition. - - :ivar name: Operation name: {provider}/{resource}/{operation}. - :vartype name: str - :ivar display: Display metadata associated with the operation. - :vartype display: ~azure.mgmt.keyvault.v2019_09_01.models.OperationDisplay - :ivar origin: The origin of operations. - :vartype origin: str - :ivar is_data_action: Property to specify whether the action is a data action. - :vartype is_data_action: bool - :ivar service_specification: One property of operation, include metric specifications. - :vartype service_specification: ~azure.mgmt.keyvault.v2019_09_01.models.ServiceSpecification - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display": {"key": "display", "type": "OperationDisplay"}, - "origin": {"key": "origin", "type": "str"}, - "is_data_action": {"key": "isDataAction", "type": "bool"}, - "service_specification": {"key": "properties.serviceSpecification", "type": "ServiceSpecification"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display: Optional["_models.OperationDisplay"] = None, - origin: Optional[str] = None, - is_data_action: Optional[bool] = None, - service_specification: Optional["_models.ServiceSpecification"] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Operation name: {provider}/{resource}/{operation}. - :paramtype name: str - :keyword display: Display metadata associated with the operation. - :paramtype display: ~azure.mgmt.keyvault.v2019_09_01.models.OperationDisplay - :keyword origin: The origin of operations. - :paramtype origin: str - :keyword is_data_action: Property to specify whether the action is a data action. - :paramtype is_data_action: bool - :keyword service_specification: One property of operation, include metric specifications. - :paramtype service_specification: ~azure.mgmt.keyvault.v2019_09_01.models.ServiceSpecification - """ - super().__init__(**kwargs) - self.name = name - self.display = display - self.origin = origin - self.is_data_action = is_data_action - self.service_specification = service_specification - - -class OperationDisplay(_serialization.Model): - """Display metadata associated with the operation. - - :ivar provider: Service provider: Microsoft Key Vault. - :vartype provider: str - :ivar resource: Resource on which the operation is performed etc. - :vartype resource: str - :ivar operation: Type of operation: get, read, delete, etc. - :vartype operation: str - :ivar description: Description of operation. - :vartype description: str - """ - - _attribute_map = { - "provider": {"key": "provider", "type": "str"}, - "resource": {"key": "resource", "type": "str"}, - "operation": {"key": "operation", "type": "str"}, - "description": {"key": "description", "type": "str"}, - } - - def __init__( - self, - *, - provider: Optional[str] = None, - resource: Optional[str] = None, - operation: Optional[str] = None, - description: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword provider: Service provider: Microsoft Key Vault. - :paramtype provider: str - :keyword resource: Resource on which the operation is performed etc. - :paramtype resource: str - :keyword operation: Type of operation: get, read, delete, etc. - :paramtype operation: str - :keyword description: Description of operation. - :paramtype description: str - """ - super().__init__(**kwargs) - self.provider = provider - self.resource = resource - self.operation = operation - self.description = description - - -class OperationListResult(_serialization.Model): - """Result of the request to list Storage operations. It contains a list of operations and a URL - link to get the next set of results. - - :ivar value: List of Storage operations supported by the Storage resource provider. - :vartype value: list[~azure.mgmt.keyvault.v2019_09_01.models.Operation] - :ivar next_link: The URL to get the next set of operations. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Operation]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Operation"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: List of Storage operations supported by the Storage resource provider. - :paramtype value: list[~azure.mgmt.keyvault.v2019_09_01.models.Operation] - :keyword next_link: The URL to get the next set of operations. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class Permissions(_serialization.Model): - """Permissions the identity has for keys, secrets, certificates and storage. - - :ivar keys: Permissions to keys. - :vartype keys: list[str or ~azure.mgmt.keyvault.v2019_09_01.models.KeyPermissions] - :ivar secrets: Permissions to secrets. - :vartype secrets: list[str or ~azure.mgmt.keyvault.v2019_09_01.models.SecretPermissions] - :ivar certificates: Permissions to certificates. - :vartype certificates: list[str or - ~azure.mgmt.keyvault.v2019_09_01.models.CertificatePermissions] - :ivar storage: Permissions to storage accounts. - :vartype storage: list[str or ~azure.mgmt.keyvault.v2019_09_01.models.StoragePermissions] - """ - - _attribute_map = { - "keys": {"key": "keys", "type": "[str]"}, - "secrets": {"key": "secrets", "type": "[str]"}, - "certificates": {"key": "certificates", "type": "[str]"}, - "storage": {"key": "storage", "type": "[str]"}, - } - - def __init__( - self, - *, - keys: Optional[List[Union[str, "_models.KeyPermissions"]]] = None, - secrets: Optional[List[Union[str, "_models.SecretPermissions"]]] = None, - certificates: Optional[List[Union[str, "_models.CertificatePermissions"]]] = None, - storage: Optional[List[Union[str, "_models.StoragePermissions"]]] = None, - **kwargs: Any - ) -> None: - """ - :keyword keys: Permissions to keys. - :paramtype keys: list[str or ~azure.mgmt.keyvault.v2019_09_01.models.KeyPermissions] - :keyword secrets: Permissions to secrets. - :paramtype secrets: list[str or ~azure.mgmt.keyvault.v2019_09_01.models.SecretPermissions] - :keyword certificates: Permissions to certificates. - :paramtype certificates: list[str or - ~azure.mgmt.keyvault.v2019_09_01.models.CertificatePermissions] - :keyword storage: Permissions to storage accounts. - :paramtype storage: list[str or ~azure.mgmt.keyvault.v2019_09_01.models.StoragePermissions] - """ - super().__init__(**kwargs) - self.keys = keys - self.secrets = secrets - self.certificates = certificates - self.storage = storage - - -class PrivateEndpoint(_serialization.Model): - """Private endpoint object properties. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Full identifier of the private endpoint resource. - :vartype id: str - """ - - _validation = { - "id": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.id = None - - -class PrivateEndpointConnection(Resource): - """Private endpoint connection resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar etag: Modified whenever there is a change in the state of private endpoint connection. - :vartype etag: str - :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpoint - :ivar private_link_service_connection_state: Approval state of the private link connection. - :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2019_09_01.models.PrivateLinkServiceConnectionState - :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values - are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnectionProvisioningState - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - "provisioning_state": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "etag": {"key": "etag", "type": "str"}, - "private_endpoint": {"key": "properties.privateEndpoint", "type": "PrivateEndpoint"}, - "private_link_service_connection_state": { - "key": "properties.privateLinkServiceConnectionState", - "type": "PrivateLinkServiceConnectionState", - }, - "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - etag: Optional[str] = None, - private_endpoint: Optional["_models.PrivateEndpoint"] = None, - private_link_service_connection_state: Optional["_models.PrivateLinkServiceConnectionState"] = None, - **kwargs: Any - ) -> None: - """ - :keyword etag: Modified whenever there is a change in the state of private endpoint connection. - :paramtype etag: str - :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpoint - :keyword private_link_service_connection_state: Approval state of the private link connection. - :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2019_09_01.models.PrivateLinkServiceConnectionState - """ - super().__init__(**kwargs) - self.etag = etag - self.private_endpoint = private_endpoint - self.private_link_service_connection_state = private_link_service_connection_state - self.provisioning_state = None - - -class PrivateEndpointConnectionItem(_serialization.Model): - """Private endpoint connection item. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Id of private endpoint connection. - :vartype id: str - :ivar etag: Modified whenever there is a change in the state of private endpoint connection. - :vartype etag: str - :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpoint - :ivar private_link_service_connection_state: Approval state of the private link connection. - :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2019_09_01.models.PrivateLinkServiceConnectionState - :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values - are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnectionProvisioningState - """ - - _validation = { - "provisioning_state": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "etag": {"key": "etag", "type": "str"}, - "private_endpoint": {"key": "properties.privateEndpoint", "type": "PrivateEndpoint"}, - "private_link_service_connection_state": { - "key": "properties.privateLinkServiceConnectionState", - "type": "PrivateLinkServiceConnectionState", - }, - "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - id: Optional[str] = None, # pylint: disable=redefined-builtin - etag: Optional[str] = None, - private_endpoint: Optional["_models.PrivateEndpoint"] = None, - private_link_service_connection_state: Optional["_models.PrivateLinkServiceConnectionState"] = None, - **kwargs: Any - ) -> None: - """ - :keyword id: Id of private endpoint connection. - :paramtype id: str - :keyword etag: Modified whenever there is a change in the state of private endpoint connection. - :paramtype etag: str - :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpoint - :keyword private_link_service_connection_state: Approval state of the private link connection. - :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2019_09_01.models.PrivateLinkServiceConnectionState - """ - super().__init__(**kwargs) - self.id = id - self.etag = etag - self.private_endpoint = private_endpoint - self.private_link_service_connection_state = private_link_service_connection_state - self.provisioning_state = None - - -class PrivateLinkResource(Resource): - """A private link resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar group_id: Group identifier of private link resource. - :vartype group_id: str - :ivar required_members: Required member names of private link resource. - :vartype required_members: list[str] - :ivar required_zone_names: Required DNS zone names of the the private link resource. - :vartype required_zone_names: list[str] - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - "group_id": {"readonly": True}, - "required_members": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "group_id": {"key": "properties.groupId", "type": "str"}, - "required_members": {"key": "properties.requiredMembers", "type": "[str]"}, - "required_zone_names": {"key": "properties.requiredZoneNames", "type": "[str]"}, - } - - def __init__(self, *, required_zone_names: Optional[List[str]] = None, **kwargs: Any) -> None: - """ - :keyword required_zone_names: Required DNS zone names of the the private link resource. - :paramtype required_zone_names: list[str] - """ - super().__init__(**kwargs) - self.group_id = None - self.required_members = None - self.required_zone_names = required_zone_names - - -class PrivateLinkResourceListResult(_serialization.Model): - """A list of private link resources. - - :ivar value: Array of private link resources. - :vartype value: list[~azure.mgmt.keyvault.v2019_09_01.models.PrivateLinkResource] - """ - - _attribute_map = { - "value": {"key": "value", "type": "[PrivateLinkResource]"}, - } - - def __init__(self, *, value: Optional[List["_models.PrivateLinkResource"]] = None, **kwargs: Any) -> None: - """ - :keyword value: Array of private link resources. - :paramtype value: list[~azure.mgmt.keyvault.v2019_09_01.models.PrivateLinkResource] - """ - super().__init__(**kwargs) - self.value = value - - -class PrivateLinkServiceConnectionState(_serialization.Model): - """An object that represents the approval state of the private link connection. - - :ivar status: Indicates whether the connection has been approved, rejected or removed by the - key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :vartype status: str or - ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointServiceConnectionStatus - :ivar description: The reason for approval or rejection. - :vartype description: str - :ivar actions_required: A message indicating if changes on the service provider require any - updates on the consumer. - :vartype actions_required: str - """ - - _attribute_map = { - "status": {"key": "status", "type": "str"}, - "description": {"key": "description", "type": "str"}, - "actions_required": {"key": "actionsRequired", "type": "str"}, - } - - def __init__( - self, - *, - status: Optional[Union[str, "_models.PrivateEndpointServiceConnectionStatus"]] = None, - description: Optional[str] = None, - actions_required: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword status: Indicates whether the connection has been approved, rejected or removed by the - key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :paramtype status: str or - ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointServiceConnectionStatus - :keyword description: The reason for approval or rejection. - :paramtype description: str - :keyword actions_required: A message indicating if changes on the service provider require any - updates on the consumer. - :paramtype actions_required: str - """ - super().__init__(**kwargs) - self.status = status - self.description = description - self.actions_required = actions_required - - -class ResourceListResult(_serialization.Model): - """List of vault resources. - - :ivar value: The list of vault resources. - :vartype value: list[~azure.mgmt.keyvault.v2019_09_01.models.Resource] - :ivar next_link: The URL to get the next set of vault resources. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Resource]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Resource"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of vault resources. - :paramtype value: list[~azure.mgmt.keyvault.v2019_09_01.models.Resource] - :keyword next_link: The URL to get the next set of vault resources. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class ServiceSpecification(_serialization.Model): - """One property of operation, include log specifications. - - :ivar log_specifications: Log specifications of operation. - :vartype log_specifications: list[~azure.mgmt.keyvault.v2019_09_01.models.LogSpecification] - :ivar metric_specifications: Metric specifications of operation. - :vartype metric_specifications: - list[~azure.mgmt.keyvault.v2019_09_01.models.MetricSpecification] - """ - - _attribute_map = { - "log_specifications": {"key": "logSpecifications", "type": "[LogSpecification]"}, - "metric_specifications": {"key": "metricSpecifications", "type": "[MetricSpecification]"}, - } - - def __init__( - self, - *, - log_specifications: Optional[List["_models.LogSpecification"]] = None, - metric_specifications: Optional[List["_models.MetricSpecification"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword log_specifications: Log specifications of operation. - :paramtype log_specifications: list[~azure.mgmt.keyvault.v2019_09_01.models.LogSpecification] - :keyword metric_specifications: Metric specifications of operation. - :paramtype metric_specifications: - list[~azure.mgmt.keyvault.v2019_09_01.models.MetricSpecification] - """ - super().__init__(**kwargs) - self.log_specifications = log_specifications - self.metric_specifications = metric_specifications - - -class Sku(_serialization.Model): - """SKU details. - - All required parameters must be populated in order to send to server. - - :ivar family: SKU family name. "A" - :vartype family: str or ~azure.mgmt.keyvault.v2019_09_01.models.SkuFamily - :ivar name: SKU name to specify whether the key vault is a standard vault or a premium vault. - Required. Known values are: "standard" and "premium". - :vartype name: str or ~azure.mgmt.keyvault.v2019_09_01.models.SkuName - """ - - _validation = { - "family": {"required": True}, - "name": {"required": True}, - } - - _attribute_map = { - "family": {"key": "family", "type": "str"}, - "name": {"key": "name", "type": "str"}, - } - - def __init__( - self, *, family: Union[str, "_models.SkuFamily"] = "A", name: Union[str, "_models.SkuName"], **kwargs: Any - ) -> None: - """ - :keyword family: SKU family name. "A" - :paramtype family: str or ~azure.mgmt.keyvault.v2019_09_01.models.SkuFamily - :keyword name: SKU name to specify whether the key vault is a standard vault or a premium - vault. Required. Known values are: "standard" and "premium". - :paramtype name: str or ~azure.mgmt.keyvault.v2019_09_01.models.SkuName - """ - super().__init__(**kwargs) - self.family = family - self.name = name - - -class Vault(_serialization.Model): - """Resource information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar properties: Properties of the vault. Required. - :vartype properties: ~azure.mgmt.keyvault.v2019_09_01.models.VaultProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "VaultProperties"}, - } - - def __init__( - self, - *, - properties: "_models.VaultProperties", - location: Optional[str] = None, - tags: Optional[Dict[str, str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: Azure location of the key vault resource. - :paramtype location: str - :keyword tags: Tags assigned to the key vault resource. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the vault. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2019_09_01.models.VaultProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = location - self.tags = tags - self.properties = properties - - -class VaultAccessPolicyParameters(_serialization.Model): - """Parameters for updating the access policy in a vault. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar id: The resource id of the access policy. - :vartype id: str - :ivar name: The resource name of the access policy. - :vartype name: str - :ivar type: The resource name of the access policy. - :vartype type: str - :ivar location: The resource type of the access policy. - :vartype location: str - :ivar properties: Properties of the access policy. Required. - :vartype properties: ~azure.mgmt.keyvault.v2019_09_01.models.VaultAccessPolicyProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "properties": {"key": "properties", "type": "VaultAccessPolicyProperties"}, - } - - def __init__(self, *, properties: "_models.VaultAccessPolicyProperties", **kwargs: Any) -> None: - """ - :keyword properties: Properties of the access policy. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2019_09_01.models.VaultAccessPolicyProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = None - self.properties = properties - - -class VaultAccessPolicyProperties(_serialization.Model): - """Properties of the vault access policy. - - All required parameters must be populated in order to send to server. - - :ivar access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. Required. - :vartype access_policies: list[~azure.mgmt.keyvault.v2019_09_01.models.AccessPolicyEntry] - """ - - _validation = { - "access_policies": {"required": True}, - } - - _attribute_map = { - "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, - } - - def __init__(self, *, access_policies: List["_models.AccessPolicyEntry"], **kwargs: Any) -> None: - """ - :keyword access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. Required. - :paramtype access_policies: list[~azure.mgmt.keyvault.v2019_09_01.models.AccessPolicyEntry] - """ - super().__init__(**kwargs) - self.access_policies = access_policies - - -class VaultCheckNameAvailabilityParameters(_serialization.Model): - """The parameters used to check the availability of the vault name. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar name: The vault name. Required. - :vartype name: str - :ivar type: The type of resource, Microsoft.KeyVault/vaults. Required. Default value is - "Microsoft.KeyVault/vaults". - :vartype type: str - """ - - _validation = { - "name": {"required": True}, - "type": {"required": True, "constant": True}, - } - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - } - - type = "Microsoft.KeyVault/vaults" - - def __init__(self, *, name: str, **kwargs: Any) -> None: - """ - :keyword name: The vault name. Required. - :paramtype name: str - """ - super().__init__(**kwargs) - self.name = name - - -class VaultCreateOrUpdateParameters(_serialization.Model): - """Parameters for creating or updating a vault. - - All required parameters must be populated in order to send to server. - - :ivar location: The supported Azure location where the key vault should be created. Required. - :vartype location: str - :ivar tags: The tags that will be assigned to the key vault. - :vartype tags: dict[str, str] - :ivar properties: Properties of the vault. Required. - :vartype properties: ~azure.mgmt.keyvault.v2019_09_01.models.VaultProperties - """ - - _validation = { - "location": {"required": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "VaultProperties"}, - } - - def __init__( - self, - *, - location: str, - properties: "_models.VaultProperties", - tags: Optional[Dict[str, str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the key vault should be created. - Required. - :paramtype location: str - :keyword tags: The tags that will be assigned to the key vault. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the vault. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2019_09_01.models.VaultProperties - """ - super().__init__(**kwargs) - self.location = location - self.tags = tags - self.properties = properties - - -class VaultListResult(_serialization.Model): - """List of vaults. - - :ivar value: The list of vaults. - :vartype value: list[~azure.mgmt.keyvault.v2019_09_01.models.Vault] - :ivar next_link: The URL to get the next set of vaults. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Vault]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Vault"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of vaults. - :paramtype value: list[~azure.mgmt.keyvault.v2019_09_01.models.Vault] - :keyword next_link: The URL to get the next set of vaults. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class VaultPatchParameters(_serialization.Model): - """Parameters for creating or updating a vault. - - :ivar tags: The tags that will be assigned to the key vault. - :vartype tags: dict[str, str] - :ivar properties: Properties of the vault. - :vartype properties: ~azure.mgmt.keyvault.v2019_09_01.models.VaultPatchProperties - """ - - _attribute_map = { - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "VaultPatchProperties"}, - } - - def __init__( - self, - *, - tags: Optional[Dict[str, str]] = None, - properties: Optional["_models.VaultPatchProperties"] = None, - **kwargs: Any - ) -> None: - """ - :keyword tags: The tags that will be assigned to the key vault. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the vault. - :paramtype properties: ~azure.mgmt.keyvault.v2019_09_01.models.VaultPatchProperties - """ - super().__init__(**kwargs) - self.tags = tags - self.properties = properties - - -class VaultPatchProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Properties of the vault. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. - :vartype tenant_id: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2019_09_01.models.Sku - :ivar access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. - :vartype access_policies: list[~azure.mgmt.keyvault.v2019_09_01.models.AccessPolicyEntry] - :ivar enabled_for_deployment: Property to specify whether Azure Virtual Machines are permitted - to retrieve certificates stored as secrets from the key vault. - :vartype enabled_for_deployment: bool - :ivar enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :vartype enabled_for_disk_encryption: bool - :ivar enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :vartype enabled_for_template_deployment: bool - :ivar enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. Once set to true, it cannot be reverted to false. - :vartype enable_soft_delete: bool - :ivar enable_rbac_authorization: Property that controls how data actions are authorized. When - true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored. When false, - the key vault will use the access policies specified in vault properties, and any policy stored - on Azure Resource Manager will be ignored. If null or not specified, the value of this property - will not change. - :vartype enable_rbac_authorization: bool - :ivar soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and <=90. - :vartype soft_delete_retention_in_days: int - :ivar create_mode: The vault's create mode to indicate whether the vault need to be recovered - or not. Known values are: "recover" and "default". - :vartype create_mode: str or ~azure.mgmt.keyvault.v2019_09_01.models.CreateMode - :ivar enable_purge_protection: Property specifying whether protection against purge is enabled - for this vault. Setting this property to true activates protection against purge for this vault - and its content - only the Key Vault service may initiate a hard, irrecoverable deletion. The - setting is effective only if soft delete is also enabled. Enabling this functionality is - irreversible - that is, the property does not accept false as its value. - :vartype enable_purge_protection: bool - :ivar network_acls: A collection of rules governing the accessibility of the vault from - specific network locations. - :vartype network_acls: ~azure.mgmt.keyvault.v2019_09_01.models.NetworkRuleSet - """ - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "sku": {"key": "sku", "type": "Sku"}, - "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, - "enabled_for_deployment": {"key": "enabledForDeployment", "type": "bool"}, - "enabled_for_disk_encryption": {"key": "enabledForDiskEncryption", "type": "bool"}, - "enabled_for_template_deployment": {"key": "enabledForTemplateDeployment", "type": "bool"}, - "enable_soft_delete": {"key": "enableSoftDelete", "type": "bool"}, - "enable_rbac_authorization": {"key": "enableRbacAuthorization", "type": "bool"}, - "soft_delete_retention_in_days": {"key": "softDeleteRetentionInDays", "type": "int"}, - "create_mode": {"key": "createMode", "type": "str"}, - "enable_purge_protection": {"key": "enablePurgeProtection", "type": "bool"}, - "network_acls": {"key": "networkAcls", "type": "NetworkRuleSet"}, - } - - def __init__( - self, - *, - tenant_id: Optional[str] = None, - sku: Optional["_models.Sku"] = None, - access_policies: Optional[List["_models.AccessPolicyEntry"]] = None, - enabled_for_deployment: Optional[bool] = None, - enabled_for_disk_encryption: Optional[bool] = None, - enabled_for_template_deployment: Optional[bool] = None, - enable_soft_delete: Optional[bool] = None, - enable_rbac_authorization: Optional[bool] = None, - soft_delete_retention_in_days: Optional[int] = None, - create_mode: Optional[Union[str, "_models.CreateMode"]] = None, - enable_purge_protection: Optional[bool] = None, - network_acls: Optional["_models.NetworkRuleSet"] = None, - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. - :paramtype tenant_id: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2019_09_01.models.Sku - :keyword access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. - :paramtype access_policies: list[~azure.mgmt.keyvault.v2019_09_01.models.AccessPolicyEntry] - :keyword enabled_for_deployment: Property to specify whether Azure Virtual Machines are - permitted to retrieve certificates stored as secrets from the key vault. - :paramtype enabled_for_deployment: bool - :keyword enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :paramtype enabled_for_disk_encryption: bool - :keyword enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :paramtype enabled_for_template_deployment: bool - :keyword enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. Once set to true, it cannot be reverted to false. - :paramtype enable_soft_delete: bool - :keyword enable_rbac_authorization: Property that controls how data actions are authorized. - When true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored. When false, - the key vault will use the access policies specified in vault properties, and any policy stored - on Azure Resource Manager will be ignored. If null or not specified, the value of this property - will not change. - :paramtype enable_rbac_authorization: bool - :keyword soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and - <=90. - :paramtype soft_delete_retention_in_days: int - :keyword create_mode: The vault's create mode to indicate whether the vault need to be - recovered or not. Known values are: "recover" and "default". - :paramtype create_mode: str or ~azure.mgmt.keyvault.v2019_09_01.models.CreateMode - :keyword enable_purge_protection: Property specifying whether protection against purge is - enabled for this vault. Setting this property to true activates protection against purge for - this vault and its content - only the Key Vault service may initiate a hard, irrecoverable - deletion. The setting is effective only if soft delete is also enabled. Enabling this - functionality is irreversible - that is, the property does not accept false as its value. - :paramtype enable_purge_protection: bool - :keyword network_acls: A collection of rules governing the accessibility of the vault from - specific network locations. - :paramtype network_acls: ~azure.mgmt.keyvault.v2019_09_01.models.NetworkRuleSet - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.sku = sku - self.access_policies = access_policies - self.enabled_for_deployment = enabled_for_deployment - self.enabled_for_disk_encryption = enabled_for_disk_encryption - self.enabled_for_template_deployment = enabled_for_template_deployment - self.enable_soft_delete = enable_soft_delete - self.enable_rbac_authorization = enable_rbac_authorization - self.soft_delete_retention_in_days = soft_delete_retention_in_days - self.create_mode = create_mode - self.enable_purge_protection = enable_purge_protection - self.network_acls = network_acls - - -class VaultProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Properties of the vault. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :vartype tenant_id: str - :ivar sku: SKU details. Required. - :vartype sku: ~azure.mgmt.keyvault.v2019_09_01.models.Sku - :ivar access_policies: An array of 0 to 1024 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. When - ``createMode`` is set to ``recover``\\ , access policies are not required. Otherwise, access - policies are required. - :vartype access_policies: list[~azure.mgmt.keyvault.v2019_09_01.models.AccessPolicyEntry] - :ivar vault_uri: The URI of the vault for performing operations on keys and secrets. This - property is readonly. - :vartype vault_uri: str - :ivar hsm_pool_resource_id: The resource id of HSM Pool. - :vartype hsm_pool_resource_id: str - :ivar enabled_for_deployment: Property to specify whether Azure Virtual Machines are permitted - to retrieve certificates stored as secrets from the key vault. - :vartype enabled_for_deployment: bool - :ivar enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :vartype enabled_for_disk_encryption: bool - :ivar enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :vartype enabled_for_template_deployment: bool - :ivar enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. If it's not set to any value(true or false) when creating new key - vault, it will be set to true by default. Once set to true, it cannot be reverted to false. - :vartype enable_soft_delete: bool - :ivar soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and <=90. - :vartype soft_delete_retention_in_days: int - :ivar enable_rbac_authorization: Property that controls how data actions are authorized. When - true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored. When false, - the key vault will use the access policies specified in vault properties, and any policy stored - on Azure Resource Manager will be ignored. If null or not specified, the vault is created with - the default value of false. Note that management actions are always authorized with RBAC. - :vartype enable_rbac_authorization: bool - :ivar create_mode: The vault's create mode to indicate whether the vault need to be recovered - or not. Known values are: "recover" and "default". - :vartype create_mode: str or ~azure.mgmt.keyvault.v2019_09_01.models.CreateMode - :ivar enable_purge_protection: Property specifying whether protection against purge is enabled - for this vault. Setting this property to true activates protection against purge for this vault - and its content - only the Key Vault service may initiate a hard, irrecoverable deletion. The - setting is effective only if soft delete is also enabled. Enabling this functionality is - irreversible - that is, the property does not accept false as its value. - :vartype enable_purge_protection: bool - :ivar network_acls: Rules governing the accessibility of the key vault from specific network - locations. - :vartype network_acls: ~azure.mgmt.keyvault.v2019_09_01.models.NetworkRuleSet - :ivar provisioning_state: Provisioning state of the vault. Known values are: "Succeeded" and - "RegisteringDns". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2019_09_01.models.VaultProvisioningState - :ivar private_endpoint_connections: List of private endpoint connections associated with the - key vault. - :vartype private_endpoint_connections: - list[~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnectionItem] - """ - - _validation = { - "tenant_id": {"required": True}, - "sku": {"required": True}, - "hsm_pool_resource_id": {"readonly": True}, - "private_endpoint_connections": {"readonly": True}, - } - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "sku": {"key": "sku", "type": "Sku"}, - "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, - "vault_uri": {"key": "vaultUri", "type": "str"}, - "hsm_pool_resource_id": {"key": "hsmPoolResourceId", "type": "str"}, - "enabled_for_deployment": {"key": "enabledForDeployment", "type": "bool"}, - "enabled_for_disk_encryption": {"key": "enabledForDiskEncryption", "type": "bool"}, - "enabled_for_template_deployment": {"key": "enabledForTemplateDeployment", "type": "bool"}, - "enable_soft_delete": {"key": "enableSoftDelete", "type": "bool"}, - "soft_delete_retention_in_days": {"key": "softDeleteRetentionInDays", "type": "int"}, - "enable_rbac_authorization": {"key": "enableRbacAuthorization", "type": "bool"}, - "create_mode": {"key": "createMode", "type": "str"}, - "enable_purge_protection": {"key": "enablePurgeProtection", "type": "bool"}, - "network_acls": {"key": "networkAcls", "type": "NetworkRuleSet"}, - "provisioning_state": {"key": "provisioningState", "type": "str"}, - "private_endpoint_connections": { - "key": "privateEndpointConnections", - "type": "[PrivateEndpointConnectionItem]", - }, - } - - def __init__( - self, - *, - tenant_id: str, - sku: "_models.Sku", - access_policies: Optional[List["_models.AccessPolicyEntry"]] = None, - vault_uri: Optional[str] = None, - enabled_for_deployment: Optional[bool] = None, - enabled_for_disk_encryption: Optional[bool] = None, - enabled_for_template_deployment: Optional[bool] = None, - enable_soft_delete: bool = True, - soft_delete_retention_in_days: int = 90, - enable_rbac_authorization: bool = False, - create_mode: Optional[Union[str, "_models.CreateMode"]] = None, - enable_purge_protection: Optional[bool] = None, - network_acls: Optional["_models.NetworkRuleSet"] = None, - provisioning_state: Optional[Union[str, "_models.VaultProvisioningState"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :paramtype tenant_id: str - :keyword sku: SKU details. Required. - :paramtype sku: ~azure.mgmt.keyvault.v2019_09_01.models.Sku - :keyword access_policies: An array of 0 to 1024 identities that have access to the key vault. - All identities in the array must use the same tenant ID as the key vault's tenant ID. When - ``createMode`` is set to ``recover``\\ , access policies are not required. Otherwise, access - policies are required. - :paramtype access_policies: list[~azure.mgmt.keyvault.v2019_09_01.models.AccessPolicyEntry] - :keyword vault_uri: The URI of the vault for performing operations on keys and secrets. This - property is readonly. - :paramtype vault_uri: str - :keyword enabled_for_deployment: Property to specify whether Azure Virtual Machines are - permitted to retrieve certificates stored as secrets from the key vault. - :paramtype enabled_for_deployment: bool - :keyword enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :paramtype enabled_for_disk_encryption: bool - :keyword enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :paramtype enabled_for_template_deployment: bool - :keyword enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. If it's not set to any value(true or false) when creating new key - vault, it will be set to true by default. Once set to true, it cannot be reverted to false. - :paramtype enable_soft_delete: bool - :keyword soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and - <=90. - :paramtype soft_delete_retention_in_days: int - :keyword enable_rbac_authorization: Property that controls how data actions are authorized. - When true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored. When false, - the key vault will use the access policies specified in vault properties, and any policy stored - on Azure Resource Manager will be ignored. If null or not specified, the vault is created with - the default value of false. Note that management actions are always authorized with RBAC. - :paramtype enable_rbac_authorization: bool - :keyword create_mode: The vault's create mode to indicate whether the vault need to be - recovered or not. Known values are: "recover" and "default". - :paramtype create_mode: str or ~azure.mgmt.keyvault.v2019_09_01.models.CreateMode - :keyword enable_purge_protection: Property specifying whether protection against purge is - enabled for this vault. Setting this property to true activates protection against purge for - this vault and its content - only the Key Vault service may initiate a hard, irrecoverable - deletion. The setting is effective only if soft delete is also enabled. Enabling this - functionality is irreversible - that is, the property does not accept false as its value. - :paramtype enable_purge_protection: bool - :keyword network_acls: Rules governing the accessibility of the key vault from specific network - locations. - :paramtype network_acls: ~azure.mgmt.keyvault.v2019_09_01.models.NetworkRuleSet - :keyword provisioning_state: Provisioning state of the vault. Known values are: "Succeeded" and - "RegisteringDns". - :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2019_09_01.models.VaultProvisioningState - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.sku = sku - self.access_policies = access_policies - self.vault_uri = vault_uri - self.hsm_pool_resource_id = None - self.enabled_for_deployment = enabled_for_deployment - self.enabled_for_disk_encryption = enabled_for_disk_encryption - self.enabled_for_template_deployment = enabled_for_template_deployment - self.enable_soft_delete = enable_soft_delete - self.soft_delete_retention_in_days = soft_delete_retention_in_days - self.enable_rbac_authorization = enable_rbac_authorization - self.create_mode = create_mode - self.enable_purge_protection = enable_purge_protection - self.network_acls = network_acls - self.provisioning_state = provisioning_state - self.private_endpoint_connections = None - - -class VirtualNetworkRule(_serialization.Model): - """A rule governing the accessibility of a vault from a specific virtual network. - - All required parameters must be populated in order to send to server. - - :ivar id: Full resource id of a vnet subnet, such as - '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. - Required. - :vartype id: str - :ivar ignore_missing_vnet_service_endpoint: Property to specify whether NRP will ignore the - check if parent subnet has serviceEndpoints configured. - :vartype ignore_missing_vnet_service_endpoint: bool - """ - - _validation = { - "id": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "ignore_missing_vnet_service_endpoint": {"key": "ignoreMissingVnetServiceEndpoint", "type": "bool"}, - } - - def __init__( - self, - *, - id: str, # pylint: disable=redefined-builtin - ignore_missing_vnet_service_endpoint: Optional[bool] = None, - **kwargs: Any - ) -> None: - """ - :keyword id: Full resource id of a vnet subnet, such as - '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. # pylint: disable=line-too-long - Required. - :paramtype id: str - :keyword ignore_missing_vnet_service_endpoint: Property to specify whether NRP will ignore the - check if parent subnet has serviceEndpoints configured. - :paramtype ignore_missing_vnet_service_endpoint: bool - """ - super().__init__(**kwargs) - self.id = id - self.ignore_missing_vnet_service_endpoint = ignore_missing_vnet_service_endpoint diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/models/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/models/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/models/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/operations/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/operations/__init__.py deleted file mode 100644 index d2cbc6d10784..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/operations/__init__.py +++ /dev/null @@ -1,27 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._vaults_operations import VaultsOperations -from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations -from ._private_link_resources_operations import PrivateLinkResourcesOperations -from ._operations import Operations -from ._keys_operations import KeysOperations - -from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "VaultsOperations", - "PrivateEndpointConnectionsOperations", - "PrivateLinkResourcesOperations", - "Operations", - "KeysOperations", -] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/operations/_keys_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/operations/_keys_operations.py deleted file mode 100644 index 33819f6c39f8..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/operations/_keys_operations.py +++ /dev/null @@ -1,658 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Optional, Type, TypeVar, Union, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_if_not_exist_request( - resource_group_name: str, vault_name: str, key_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "keyName": _SERIALIZER.url("key_name", key_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request( - resource_group_name: str, vault_name: str, key_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "keyName": _SERIALIZER.url("key_name", key_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_version_request( - resource_group_name: str, vault_name: str, key_name: str, key_version: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "keyName": _SERIALIZER.url("key_name", key_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - "keyVersion": _SERIALIZER.url("key_version", key_version, "str", pattern=r"^[a-fA-F0-9]{32}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_versions_request( - resource_group_name: str, vault_name: str, key_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "keyName": _SERIALIZER.url("key_name", key_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class KeysOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2019_09_01.KeyVaultManagementClient`'s - :attr:`keys` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @overload - def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: _models.KeyCreateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Required. - :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.KeyCreateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: Union[_models.KeyCreateParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Is either a - KeyCreateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.KeyCreateParameters or IO[bytes] - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "KeyCreateParameters") - - _request = build_create_if_not_exist_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def get(self, resource_group_name: str, vault_name: str, key_name: str, **kwargs: Any) -> _models.Key: - """Gets the current version of the specified key from the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key to be retrieved. Required. - :type vault_name: str - :param key_name: The name of the key to be retrieved. Required. - :type key_name: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> Iterable["_models.Key"]: - """Lists the keys in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the keys to be retrieved. Required. - :type vault_name: str - :return: An iterator like instance of either Key or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.Key] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("KeyListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def get_version( - self, resource_group_name: str, vault_name: str, key_name: str, key_version: str, **kwargs: Any - ) -> _models.Key: - """Gets the specified version of the specified key in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key version to be retrieved. - Required. - :type vault_name: str - :param key_name: The name of the key version to be retrieved. Required. - :type key_name: str - :param key_version: The version of the key to be retrieved. Required. - :type key_version: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - _request = build_get_version_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - key_version=key_version, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_versions( - self, resource_group_name: str, vault_name: str, key_name: str, **kwargs: Any - ) -> Iterable["_models.Key"]: - """Lists the versions of the specified key in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key versions to be retrieved. - Required. - :type vault_name: str - :param key_name: The name of the key versions to be retrieved. Required. - :type key_name: str - :return: An iterator like instance of either Key or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.Key] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_versions_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("KeyListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/operations/_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/operations/_operations.py deleted file mode 100644 index 2f45c5b92f46..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/operations/_operations.py +++ /dev/null @@ -1,152 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Iterable, Optional, Type, TypeVar -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_request(**kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/providers/Microsoft.KeyVault/operations") - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class Operations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2019_09_01.KeyVaultManagementClient`'s - :attr:`operations` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: - """Lists all of the available Key Vault Rest API operations. - - :return: An iterator like instance of either Operation or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.Operation] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("OperationListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/operations/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/operations/_patch.py deleted file mode 100644 index 9c719e411990..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/operations/_patch.py +++ /dev/null @@ -1,134 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -import sys -from typing import Any, List, Iterable, Optional, Type -import urllib.parse - -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.rest import HttpRequest -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ._vaults_operations import VaultsOperations as _VaultsOperations, ClsType, build_list_request -from .. import models as _models - -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports - -class VaultsOperations(_VaultsOperations): - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - -__all__: List[str] = ["VaultsOperations"] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/operations/_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/operations/_private_endpoint_connections_operations.py deleted file mode 100644 index 935ce01821c8..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/operations/_private_endpoint_connections_operations.py +++ /dev/null @@ -1,509 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterator, Optional, Type, TypeVar, Union, cast, overload - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_get_request( - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_put_request( - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request( - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -class PrivateEndpointConnectionsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2019_09_01.KeyVaultManagementClient`'s - :attr:`private_endpoint_connections` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def get( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Optional[_models.PrivateEndpointConnection]: - """Gets the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: PrivateEndpointConnection or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection or None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[Optional[_models.PrivateEndpointConnection]] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: _models.PrivateEndpointConnection, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: Union[_models.PrivateEndpointConnection, IO[bytes]], - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Is either a - PrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection or - IO[bytes] - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _json = self._serialize.body(properties, "PrivateEndpointConnection") - - _request = build_put_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Azure-AsyncOperation"] = self._deserialize( - "str", response.headers.get("Azure-AsyncOperation") - ) - - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - def _delete_initial( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_delete( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> LROPoller[_models.PrivateEndpointConnection]: - """Deletes the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: An instance of LROPoller that returns either PrivateEndpointConnection or the result - of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._delete_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.PrivateEndpointConnection].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.PrivateEndpointConnection]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/operations/_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/operations/_private_link_resources_operations.py deleted file mode 100644 index a466f79ce405..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/operations/_private_link_resources_operations.py +++ /dev/null @@ -1,145 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_by_vault_request( - resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class PrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2019_09_01.KeyVaultManagementClient`'s - :attr:`private_link_resources` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list_by_vault( - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> _models.PrivateLinkResourceListResult: - """Gets the private link resources supported for the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :return: PrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateLinkResourceListResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.PrivateLinkResourceListResult] = kwargs.pop("cls", None) - - _request = build_list_by_vault_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/operations/_vaults_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/operations/_vaults_operations.py deleted file mode 100644 index a042afe5031b..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/operations/_vaults_operations.py +++ /dev/null @@ -1,1581 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Literal, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_or_update_request( - resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_access_policy_request( - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "operationKind": _SERIALIZER.url("operation_kind", operation_kind, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_resource_group_request( - resource_group_name: str, subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_subscription_request( - subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_deleted_request(subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_deleted_request(vault_name: str, location: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "location": _SERIALIZER.url("location", location, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_purge_deleted_request(vault_name: str, location: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge", - ) # pylint: disable=line-too-long - path_format_arguments = { - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "location": _SERIALIZER.url("location", location, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_request(subscription_id: str, *, top: Optional[int] = None, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop("api_version", _params.pop("api-version", "2015-11-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resources") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["$filter"] = _SERIALIZER.query("filter", filter, "str") - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_check_name_availability_request(subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability" - ) - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -class VaultsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2019_09_01.KeyVaultManagementClient`'s - :attr:`vaults` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - def _create_or_update_initial( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 201: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.VaultCreateOrUpdateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2019_09_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2019_09_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> LROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Is either a - VaultCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.VaultCreateOrUpdateParameters or - IO[bytes] - :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2019_09_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._create_or_update_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("Vault", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.Vault].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.Vault]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @overload - def update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultPatchParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.VaultPatchParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultPatchParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Is either a VaultPatchParameters type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.VaultPatchParameters or IO[bytes] - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultPatchParameters") - - _request = build_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def delete( # pylint: disable=inconsistent-return-statements - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> None: - """Deletes the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault to delete. Required. - :type vault_name: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - @distributed_trace - def get(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> _models.Vault: - """Gets the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: _models.VaultAccessPolicyParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2019_09_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.VaultAccessPolicyParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2019_09_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: Union[_models.VaultAccessPolicyParameters, IO[bytes]], - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2019_09_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Is either a - VaultAccessPolicyParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.VaultAccessPolicyParameters or - IO[bytes] - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.VaultAccessPolicyParameters] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") - - _request = build_update_access_policy_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - operation_kind=operation_kind, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> Iterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription and - within the specified resource group. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedVault"]: - """Gets information about the deleted vaults in a subscription. - - :return: An iterator like instance of either DeletedVault or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.DeletedVault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.DeletedVaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("DeletedVaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _models.DeletedVault: - """Gets the deleted Azure key vault. - - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param location: The location of the deleted vault. Required. - :type location: str - :return: DeletedVault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.DeletedVault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[_models.DeletedVault] = kwargs.pop("cls", None) - - _request = build_get_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("DeletedVault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_purge_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_purge_deleted(self, vault_name: str, location: str, **kwargs: Any) -> LROPoller[None]: - """Permanently deletes the specified vault. aka Purges the deleted Azure key vault. - - :param vault_name: The name of the soft-deleted vault. Required. - :type vault_name: str - :param location: The location of the soft-deleted vault. Required. - :type location: str - :return: An instance of LROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._purge_deleted_initial( - vault_name=vault_name, - location=location, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @overload - def check_name_availability( - self, - vault_name: _models.VaultCheckNameAvailabilityParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: ~azure.mgmt.keyvault.v2019_09_01.models.VaultCheckNameAvailabilityParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def check_name_availability( - self, vault_name: IO[bytes], *, content_type: str = "application/json", **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def check_name_availability( - self, vault_name: Union[_models.VaultCheckNameAvailabilityParameters, IO[bytes]], **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Is either a VaultCheckNameAvailabilityParameters type - or a IO[bytes] type. Required. - :type vault_name: ~azure.mgmt.keyvault.v2019_09_01.models.VaultCheckNameAvailabilityParameters - or IO[bytes] - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.CheckNameAvailabilityResult] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(vault_name, (IOBase, bytes)): - _content = vault_name - else: - _json = self._serialize.body(vault_name, "VaultCheckNameAvailabilityParameters") - - _request = build_check_name_availability_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/py.typed b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/py.typed deleted file mode 100644 index e5aff4f83af8..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/py.typed +++ /dev/null @@ -1 +0,0 @@ -# Marker file for PEP 561. \ No newline at end of file diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/_configuration.py deleted file mode 100644 index 5121986ee3c6..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/_configuration.py +++ /dev/null @@ -1,66 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from typing import Any, TYPE_CHECKING - -from azure.core.pipeline import policies -from azure.mgmt.core.policies import ARMChallengeAuthenticationPolicy, ARMHttpLoggingPolicy - -from ._version import VERSION - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials import TokenCredential - - -class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long - """Configuration for KeyVaultManagementClient. - - Note that all parameters used to create this instance are saved as instance - attributes. - - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials.TokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :keyword api_version: Api Version. Default value is "2020-04-01-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str - """ - - def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None: - api_version: str = kwargs.pop("api_version", "2020-04-01-preview") - - if credential is None: - raise ValueError("Parameter 'credential' must not be None.") - if subscription_id is None: - raise ValueError("Parameter 'subscription_id' must not be None.") - - self.credential = credential - self.subscription_id = subscription_id - self.api_version = api_version - self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) - kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) - self.polling_interval = kwargs.get("polling_interval", 30) - self._configure(**kwargs) - - def _configure(self, **kwargs: Any) -> None: - 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.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**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) - self.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs) - self.authentication_policy = kwargs.get("authentication_policy") - if self.credential and not self.authentication_policy: - self.authentication_policy = ARMChallengeAuthenticationPolicy( - self.credential, *self.credential_scopes, **kwargs - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/_key_vault_management_client.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/_key_vault_management_client.py deleted file mode 100644 index cfba0db201b9..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/_key_vault_management_client.py +++ /dev/null @@ -1,154 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from copy import deepcopy -from typing import Any, TYPE_CHECKING -from typing_extensions import Self - -from azure.core.pipeline import policies -from azure.core.rest import HttpRequest, HttpResponse -from azure.mgmt.core import ARMPipelineClient -from azure.mgmt.core.policies import ARMAutoResourceProviderRegistrationPolicy - -from . import models as _models -from .._serialization import Deserializer, Serializer -from ._configuration import KeyVaultManagementClientConfiguration -from .operations import ( - KeysOperations, - ManagedHsmsOperations, - Operations, - PrivateEndpointConnectionsOperations, - PrivateLinkResourcesOperations, - SecretsOperations, - VaultsOperations, -) - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials import TokenCredential - - -class KeyVaultManagementClient: # pylint: disable=client-accepts-api-version-keyword,too-many-instance-attributes - """The Azure management API provides a RESTful set of web services that interact with Azure Key - Vault. - - :ivar keys: KeysOperations operations - :vartype keys: azure.mgmt.keyvault.v2020_04_01_preview.operations.KeysOperations - :ivar vaults: VaultsOperations operations - :vartype vaults: azure.mgmt.keyvault.v2020_04_01_preview.operations.VaultsOperations - :ivar private_endpoint_connections: PrivateEndpointConnectionsOperations operations - :vartype private_endpoint_connections: - azure.mgmt.keyvault.v2020_04_01_preview.operations.PrivateEndpointConnectionsOperations - :ivar private_link_resources: PrivateLinkResourcesOperations operations - :vartype private_link_resources: - azure.mgmt.keyvault.v2020_04_01_preview.operations.PrivateLinkResourcesOperations - :ivar operations: Operations operations - :vartype operations: azure.mgmt.keyvault.v2020_04_01_preview.operations.Operations - :ivar secrets: SecretsOperations operations - :vartype secrets: azure.mgmt.keyvault.v2020_04_01_preview.operations.SecretsOperations - :ivar managed_hsms: ManagedHsmsOperations operations - :vartype managed_hsms: azure.mgmt.keyvault.v2020_04_01_preview.operations.ManagedHsmsOperations - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials.TokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :param base_url: Service URL. Default value is "https://management.azure.com". - :type base_url: str - :keyword api_version: Api Version. Default value is "2020-04-01-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. - """ - - def __init__( - self, - credential: "TokenCredential", - subscription_id: str, - base_url: str = "https://management.azure.com", - **kwargs: Any - ) -> None: - self._config = KeyVaultManagementClientConfiguration( - credential=credential, subscription_id=subscription_id, **kwargs - ) - _policies = kwargs.pop("policies", None) - if _policies is None: - _policies = [ - policies.RequestIdPolicy(**kwargs), - self._config.headers_policy, - self._config.user_agent_policy, - self._config.proxy_policy, - policies.ContentDecodePolicy(**kwargs), - ARMAutoResourceProviderRegistrationPolicy(), - self._config.redirect_policy, - self._config.retry_policy, - self._config.authentication_policy, - self._config.custom_hook_policy, - self._config.logging_policy, - policies.DistributedTracingPolicy(**kwargs), - policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, - self._config.http_logging_policy, - ] - self._client: ARMPipelineClient = ARMPipelineClient(base_url=base_url, policies=_policies, **kwargs) - - client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} - self._serialize = Serializer(client_models) - self._deserialize = Deserializer(client_models) - self._serialize.client_side_validation = False - self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize, "2020-04-01-preview") - self.vaults = VaultsOperations( - self._client, self._config, self._serialize, self._deserialize, "2020-04-01-preview" - ) - self.private_endpoint_connections = PrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2020-04-01-preview" - ) - self.private_link_resources = PrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2020-04-01-preview" - ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize, "2020-04-01-preview" - ) - self.secrets = SecretsOperations( - self._client, self._config, self._serialize, self._deserialize, "2020-04-01-preview" - ) - self.managed_hsms = ManagedHsmsOperations( - self._client, self._config, self._serialize, self._deserialize, "2020-04-01-preview" - ) - - def _send_request(self, request: HttpRequest, *, stream: bool = False, **kwargs: Any) -> HttpResponse: - """Runs the network request through the client's chained policies. - - >>> from azure.core.rest import HttpRequest - >>> request = HttpRequest("GET", "https://www.example.org/") - - >>> response = client._send_request(request) - - - For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request - - :param request: The network request you want to make. Required. - :type request: ~azure.core.rest.HttpRequest - :keyword bool stream: Whether the response payload will be streamed. Defaults to False. - :return: The response of your network call. Does not do error handling on your response. - :rtype: ~azure.core.rest.HttpResponse - """ - - request_copy = deepcopy(request) - request_copy.url = self._client.format_url(request_copy.url) - return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore - - def close(self) -> None: - self._client.close() - - def __enter__(self) -> Self: - self._client.__enter__() - return self - - def __exit__(self, *exc_details: Any) -> None: - self._client.__exit__(*exc_details) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/_metadata.json b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/_metadata.json deleted file mode 100644 index 99a9459a65de..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/_metadata.json +++ /dev/null @@ -1,116 +0,0 @@ -{ - "chosen_version": "2020-04-01-preview", - "total_api_version_list": ["2020-04-01-preview"], - "client": { - "name": "KeyVaultManagementClient", - "filename": "_key_vault_management_client", - "description": "The Azure management API provides a RESTful set of web services that interact with Azure Key Vault.", - "host_value": "\"https://management.azure.com\"", - "parameterized_host_template": null, - "azure_arm": true, - "has_public_lro_operations": true, - "client_side_validation": false, - "sync_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"sdkcore\": {\"azure.mgmt.core\": [\"ARMPipelineClient\"], \"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"ARMAutoResourceProviderRegistrationPolicy\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \".._serialization\": [\"Deserializer\", \"Serializer\"]}, \"stdlib\": {\"typing_extensions\": [\"Self\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}}", - "async_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"sdkcore\": {\"azure.mgmt.core\": [\"AsyncARMPipelineClient\"], \"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"AsyncARMAutoResourceProviderRegistrationPolicy\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \"..._serialization\": [\"Deserializer\", \"Serializer\"]}, \"stdlib\": {\"typing_extensions\": [\"Self\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"]}}}" - }, - "global_parameters": { - "sync": { - "credential": { - "signature": "credential: \"TokenCredential\",", - "description": "Credential needed for the client to connect to Azure. Required.", - "docstring_type": "~azure.core.credentials.TokenCredential", - "required": true, - "method_location": "positional" - }, - "subscription_id": { - "signature": "subscription_id: str,", - "description": "Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. Required.", - "docstring_type": "str", - "required": true, - "method_location": "positional" - } - }, - "async": { - "credential": { - "signature": "credential: \"AsyncTokenCredential\",", - "description": "Credential needed for the client to connect to Azure. Required.", - "docstring_type": "~azure.core.credentials_async.AsyncTokenCredential", - "required": true - }, - "subscription_id": { - "signature": "subscription_id: str,", - "description": "Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. Required.", - "docstring_type": "str", - "required": true - } - }, - "constant": { - }, - "call": "credential, subscription_id", - "service_client_specific": { - "sync": { - "api_version": { - "signature": "api_version: Optional[str]=None,", - "description": "API version to use if no profile is provided, or if missing in profile.", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "base_url": { - "signature": "base_url: str = \"https://management.azure.com\",", - "description": "Service URL", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "profile": { - "signature": "profile: KnownProfiles=KnownProfiles.default,", - "description": "A profile definition, from KnownProfiles to dict.", - "docstring_type": "azure.profiles.KnownProfiles", - "required": false, - "method_location": "positional" - } - }, - "async": { - "api_version": { - "signature": "api_version: Optional[str] = None,", - "description": "API version to use if no profile is provided, or if missing in profile.", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "base_url": { - "signature": "base_url: str = \"https://management.azure.com\",", - "description": "Service URL", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "profile": { - "signature": "profile: KnownProfiles = KnownProfiles.default,", - "description": "A profile definition, from KnownProfiles to dict.", - "docstring_type": "azure.profiles.KnownProfiles", - "required": false, - "method_location": "positional" - } - } - } - }, - "config": { - "credential": true, - "credential_scopes": ["https://management.azure.com/.default"], - "credential_call_sync": "ARMChallengeAuthenticationPolicy(self.credential, *self.credential_scopes, **kwargs)", - "credential_call_async": "AsyncARMChallengeAuthenticationPolicy(self.credential, *self.credential_scopes, **kwargs)", - "sync_imports": "{\"regular\": {\"sdkcore\": {\"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"ARMChallengeAuthenticationPolicy\", \"ARMHttpLoggingPolicy\"]}, \"local\": {\"._version\": [\"VERSION\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}}", - "async_imports": "{\"regular\": {\"sdkcore\": {\"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"ARMHttpLoggingPolicy\", \"AsyncARMChallengeAuthenticationPolicy\"]}, \"local\": {\".._version\": [\"VERSION\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"]}}}" - }, - "operation_groups": { - "keys": "KeysOperations", - "vaults": "VaultsOperations", - "private_endpoint_connections": "PrivateEndpointConnectionsOperations", - "private_link_resources": "PrivateLinkResourcesOperations", - "operations": "Operations", - "secrets": "SecretsOperations", - "managed_hsms": "ManagedHsmsOperations" - } -} diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/_version.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/_version.py deleted file mode 100644 index 3b99a1418535..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/_version.py +++ /dev/null @@ -1,9 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -VERSION = "10.3.1" diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/__init__.py deleted file mode 100644 index 6ba0c5a05353..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/__init__.py +++ /dev/null @@ -1,23 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._key_vault_management_client import KeyVaultManagementClient - -try: - from ._patch import __all__ as _patch_all - from ._patch import * # pylint: disable=unused-wildcard-import -except ImportError: - _patch_all = [] -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "KeyVaultManagementClient", -] -__all__.extend([p for p in _patch_all if p not in __all__]) - -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/_configuration.py deleted file mode 100644 index 8da4798046cf..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/_configuration.py +++ /dev/null @@ -1,66 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from typing import Any, TYPE_CHECKING - -from azure.core.pipeline import policies -from azure.mgmt.core.policies import ARMHttpLoggingPolicy, AsyncARMChallengeAuthenticationPolicy - -from .._version import VERSION - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials_async import AsyncTokenCredential - - -class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long - """Configuration for KeyVaultManagementClient. - - Note that all parameters used to create this instance are saved as instance - attributes. - - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials_async.AsyncTokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :keyword api_version: Api Version. Default value is "2020-04-01-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str - """ - - def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None: - api_version: str = kwargs.pop("api_version", "2020-04-01-preview") - - if credential is None: - raise ValueError("Parameter 'credential' must not be None.") - if subscription_id is None: - raise ValueError("Parameter 'subscription_id' must not be None.") - - self.credential = credential - self.subscription_id = subscription_id - self.api_version = api_version - self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) - kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) - self.polling_interval = kwargs.get("polling_interval", 30) - self._configure(**kwargs) - - def _configure(self, **kwargs: Any) -> None: - 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.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**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) - self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) - self.authentication_policy = kwargs.get("authentication_policy") - if self.credential and not self.authentication_policy: - self.authentication_policy = AsyncARMChallengeAuthenticationPolicy( - self.credential, *self.credential_scopes, **kwargs - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/_key_vault_management_client.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/_key_vault_management_client.py deleted file mode 100644 index e9786903cee8..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/_key_vault_management_client.py +++ /dev/null @@ -1,157 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from copy import deepcopy -from typing import Any, Awaitable, TYPE_CHECKING -from typing_extensions import Self - -from azure.core.pipeline import policies -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.mgmt.core import AsyncARMPipelineClient -from azure.mgmt.core.policies import AsyncARMAutoResourceProviderRegistrationPolicy - -from .. import models as _models -from ..._serialization import Deserializer, Serializer -from ._configuration import KeyVaultManagementClientConfiguration -from .operations import ( - KeysOperations, - ManagedHsmsOperations, - Operations, - PrivateEndpointConnectionsOperations, - PrivateLinkResourcesOperations, - SecretsOperations, - VaultsOperations, -) - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials_async import AsyncTokenCredential - - -class KeyVaultManagementClient: # pylint: disable=client-accepts-api-version-keyword,too-many-instance-attributes - """The Azure management API provides a RESTful set of web services that interact with Azure Key - Vault. - - :ivar keys: KeysOperations operations - :vartype keys: azure.mgmt.keyvault.v2020_04_01_preview.aio.operations.KeysOperations - :ivar vaults: VaultsOperations operations - :vartype vaults: azure.mgmt.keyvault.v2020_04_01_preview.aio.operations.VaultsOperations - :ivar private_endpoint_connections: PrivateEndpointConnectionsOperations operations - :vartype private_endpoint_connections: - azure.mgmt.keyvault.v2020_04_01_preview.aio.operations.PrivateEndpointConnectionsOperations - :ivar private_link_resources: PrivateLinkResourcesOperations operations - :vartype private_link_resources: - azure.mgmt.keyvault.v2020_04_01_preview.aio.operations.PrivateLinkResourcesOperations - :ivar operations: Operations operations - :vartype operations: azure.mgmt.keyvault.v2020_04_01_preview.aio.operations.Operations - :ivar secrets: SecretsOperations operations - :vartype secrets: azure.mgmt.keyvault.v2020_04_01_preview.aio.operations.SecretsOperations - :ivar managed_hsms: ManagedHsmsOperations operations - :vartype managed_hsms: - azure.mgmt.keyvault.v2020_04_01_preview.aio.operations.ManagedHsmsOperations - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials_async.AsyncTokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :param base_url: Service URL. Default value is "https://management.azure.com". - :type base_url: str - :keyword api_version: Api Version. Default value is "2020-04-01-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. - """ - - def __init__( - self, - credential: "AsyncTokenCredential", - subscription_id: str, - base_url: str = "https://management.azure.com", - **kwargs: Any - ) -> None: - self._config = KeyVaultManagementClientConfiguration( - credential=credential, subscription_id=subscription_id, **kwargs - ) - _policies = kwargs.pop("policies", None) - if _policies is None: - _policies = [ - policies.RequestIdPolicy(**kwargs), - self._config.headers_policy, - self._config.user_agent_policy, - self._config.proxy_policy, - policies.ContentDecodePolicy(**kwargs), - AsyncARMAutoResourceProviderRegistrationPolicy(), - self._config.redirect_policy, - self._config.retry_policy, - self._config.authentication_policy, - self._config.custom_hook_policy, - self._config.logging_policy, - policies.DistributedTracingPolicy(**kwargs), - policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, - self._config.http_logging_policy, - ] - self._client: AsyncARMPipelineClient = AsyncARMPipelineClient(base_url=base_url, policies=_policies, **kwargs) - - client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} - self._serialize = Serializer(client_models) - self._deserialize = Deserializer(client_models) - self._serialize.client_side_validation = False - self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize, "2020-04-01-preview") - self.vaults = VaultsOperations( - self._client, self._config, self._serialize, self._deserialize, "2020-04-01-preview" - ) - self.private_endpoint_connections = PrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2020-04-01-preview" - ) - self.private_link_resources = PrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2020-04-01-preview" - ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize, "2020-04-01-preview" - ) - self.secrets = SecretsOperations( - self._client, self._config, self._serialize, self._deserialize, "2020-04-01-preview" - ) - self.managed_hsms = ManagedHsmsOperations( - self._client, self._config, self._serialize, self._deserialize, "2020-04-01-preview" - ) - - def _send_request( - self, request: HttpRequest, *, stream: bool = False, **kwargs: Any - ) -> Awaitable[AsyncHttpResponse]: - """Runs the network request through the client's chained policies. - - >>> from azure.core.rest import HttpRequest - >>> request = HttpRequest("GET", "https://www.example.org/") - - >>> response = await client._send_request(request) - - - For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request - - :param request: The network request you want to make. Required. - :type request: ~azure.core.rest.HttpRequest - :keyword bool stream: Whether the response payload will be streamed. Defaults to False. - :return: The response of your network call. Does not do error handling on your response. - :rtype: ~azure.core.rest.AsyncHttpResponse - """ - - request_copy = deepcopy(request) - request_copy.url = self._client.format_url(request_copy.url) - return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore - - async def close(self) -> None: - await self._client.close() - - async def __aenter__(self) -> Self: - await self._client.__aenter__() - return self - - async def __aexit__(self, *exc_details: Any) -> None: - await self._client.__aexit__(*exc_details) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/__init__.py deleted file mode 100644 index a86b1e14cf52..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/__init__.py +++ /dev/null @@ -1,31 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._keys_operations import KeysOperations -from ._vaults_operations import VaultsOperations -from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations -from ._private_link_resources_operations import PrivateLinkResourcesOperations -from ._operations import Operations -from ._secrets_operations import SecretsOperations -from ._managed_hsms_operations import ManagedHsmsOperations - -from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "KeysOperations", - "VaultsOperations", - "PrivateEndpointConnectionsOperations", - "PrivateLinkResourcesOperations", - "Operations", - "SecretsOperations", - "ManagedHsmsOperations", -] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_keys_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_keys_operations.py deleted file mode 100644 index 5045779820d9..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_keys_operations.py +++ /dev/null @@ -1,514 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, Type, TypeVar, Union, overload -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._keys_operations import ( - build_create_if_not_exist_request, - build_get_request, - build_get_version_request, - build_list_request, - build_list_versions_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class KeysOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2020_04_01_preview.aio.KeyVaultManagementClient`'s - :attr:`keys` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @overload - async def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: _models.KeyCreateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.KeyCreateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: Union[_models.KeyCreateParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Is either a - KeyCreateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.KeyCreateParameters or - IO[bytes] - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "KeyCreateParameters") - - _request = build_create_if_not_exist_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def get(self, resource_group_name: str, vault_name: str, key_name: str, **kwargs: Any) -> _models.Key: - """Gets the current version of the specified key from the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key to be retrieved. Required. - :type vault_name: str - :param key_name: The name of the key to be retrieved. Required. - :type key_name: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> AsyncIterable["_models.Key"]: - """Lists the keys in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the keys to be retrieved. Required. - :type vault_name: str - :return: An iterator like instance of either Key or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.Key] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("KeyListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace_async - async def get_version( - self, resource_group_name: str, vault_name: str, key_name: str, key_version: str, **kwargs: Any - ) -> _models.Key: - """Gets the specified version of the specified key in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key version to be retrieved. - Required. - :type vault_name: str - :param key_name: The name of the key version to be retrieved. Required. - :type key_name: str - :param key_version: The version of the key to be retrieved. Required. - :type key_version: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - _request = build_get_version_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - key_version=key_version, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_versions( - self, resource_group_name: str, vault_name: str, key_name: str, **kwargs: Any - ) -> AsyncIterable["_models.Key"]: - """Lists the versions of the specified key in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key versions to be retrieved. - Required. - :type vault_name: str - :param key_name: The name of the key versions to be retrieved. Required. - :type key_name: str - :return: An iterator like instance of either Key or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.Key] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_versions_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("KeyListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_managed_hsms_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_managed_hsms_operations.py deleted file mode 100644 index ea6d0233544f..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_managed_hsms_operations.py +++ /dev/null @@ -1,794 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._managed_hsms_operations import ( - build_create_or_update_request, - build_delete_request, - build_get_request, - build_list_by_resource_group_request, - build_list_by_subscription_request, - build_update_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class ManagedHsmsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2020_04_01_preview.aio.KeyVaultManagementClient`'s - :attr:`managed_hsms` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - async def _create_or_update_initial( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "ManagedHsm") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def begin_create_or_update( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Is either a ManagedHsm - type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm or IO[bytes] - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._create_or_update_initial( - resource_group_name=resource_group_name, - name=name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.ManagedHsm].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.ManagedHsm]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - async def _update_initial( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "ManagedHsm") - - _request = build_update_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @overload - async def begin_update( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_update( - self, - resource_group_name: str, - name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def begin_update( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Is either a ManagedHsm type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm or IO[bytes] - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._update_initial( - resource_group_name=resource_group_name, - name=name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.ManagedHsm].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.ManagedHsm]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - async def _delete_initial(self, resource_group_name: str, name: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_delete(self, resource_group_name: str, name: str, **kwargs: Any) -> AsyncLROPoller[None]: - """Deletes the specified managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: The name of the managed HSM Pool to delete. Required. - :type name: str - :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._delete_initial( - resource_group_name=resource_group_name, - name=name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace_async - async def get(self, resource_group_name: str, name: str, **kwargs: Any) -> Optional[_models.ManagedHsm]: - """Gets the specified managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: The name of the managed HSM Pool. Required. - :type name: str - :return: ManagedHsm or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm or None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[Optional[_models.ManagedHsm]] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable["_models.ManagedHsm"]: - """The List operation gets information about the managed HSM Pools associated with the - subscription and within the specified resource group. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.ManagedHsm"]: - """The List operation gets information about the managed HSM Pools associated with the - subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_operations.py deleted file mode 100644 index 9184299d7d14..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_operations.py +++ /dev/null @@ -1,133 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, AsyncIterable, Callable, Dict, Optional, Type, TypeVar -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._operations import build_list_request - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class Operations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2020_04_01_preview.aio.KeyVaultManagementClient`'s - :attr:`operations` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: - """Lists all of the available Key Vault Rest API operations. - - :return: An iterator like instance of either Operation or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.Operation] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("OperationListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_patch.py deleted file mode 100644 index 9b4f32f151b7..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_patch.py +++ /dev/null @@ -1,136 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -import sys -from typing import AsyncIterable, Any, Optional, List, Type -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ._vaults_operations import VaultsOperations as _VaultsOperations, ClsType -from ...operations._vaults_operations import build_list_request - -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports - -class VaultsOperations(_VaultsOperations): - - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - -__all__: List[str] = ["VaultsOperations"] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_private_endpoint_connections_operations.py deleted file mode 100644 index 680b54a3c35b..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_private_endpoint_connections_operations.py +++ /dev/null @@ -1,401 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterator, Callable, Dict, IO, Optional, Type, TypeVar, Union, cast, overload - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._private_endpoint_connections_operations import ( - build_delete_request, - build_get_request, - build_put_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class PrivateEndpointConnectionsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2020_04_01_preview.aio.KeyVaultManagementClient`'s - :attr:`private_endpoint_connections` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace_async - async def get( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Optional[_models.PrivateEndpointConnection]: - """Gets the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: PrivateEndpointConnection or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnection or None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[Optional[_models.PrivateEndpointConnection]] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: _models.PrivateEndpointConnection, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnection - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: Union[_models.PrivateEndpointConnection, IO[bytes]], - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Is either a - PrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnection or - IO[bytes] - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _json = self._serialize.body(properties, "PrivateEndpointConnection") - - _request = build_put_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Azure-AsyncOperation"] = self._deserialize( - "str", response.headers.get("Azure-AsyncOperation") - ) - - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - async def _delete_initial( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_delete( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> AsyncLROPoller[_models.PrivateEndpointConnection]: - """Deletes the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: An instance of AsyncLROPoller that returns either PrivateEndpointConnection or the - result of cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._delete_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.PrivateEndpointConnection].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.PrivateEndpointConnection]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_private_link_resources_operations.py deleted file mode 100644 index 63c08ce81443..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_private_link_resources_operations.py +++ /dev/null @@ -1,113 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._private_link_resources_operations import build_list_by_vault_request - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class PrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2020_04_01_preview.aio.KeyVaultManagementClient`'s - :attr:`private_link_resources` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace_async - async def list_by_vault( - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> _models.PrivateLinkResourceListResult: - """Gets the private link resources supported for the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :return: PrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateLinkResourceListResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.PrivateLinkResourceListResult] = kwargs.pop("cls", None) - - _request = build_list_by_vault_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_secrets_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_secrets_operations.py deleted file mode 100644 index c168374c3094..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_secrets_operations.py +++ /dev/null @@ -1,523 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, Type, TypeVar, Union, overload -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._secrets_operations import ( - build_create_or_update_request, - build_get_request, - build_list_request, - build_update_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class SecretsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2020_04_01_preview.aio.KeyVaultManagementClient`'s - :attr:`secrets` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @overload - async def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: _models.SecretCreateOrUpdateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Required. - :type parameters: - ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretCreateOrUpdateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: Union[_models.SecretCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Is either a - SecretCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: - ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretCreateOrUpdateParameters or IO[bytes] - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "SecretCreateOrUpdateParameters") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: _models.SecretPatchParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretPatchParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: Union[_models.SecretPatchParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Is either a SecretPatchParameters type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretPatchParameters or - IO[bytes] - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "SecretPatchParameters") - - _request = build_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def get(self, resource_group_name: str, vault_name: str, secret_name: str, **kwargs: Any) -> _models.Secret: - """Gets the specified secret. NOTE: This API is intended for internal use in ARM deployments. - Users should use the data-plane REST service for interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param secret_name: The name of the secret. Required. - :type secret_name: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list( - self, resource_group_name: str, vault_name: str, top: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable["_models.Secret"]: - """The List operation gets information about the secrets in a vault. NOTE: This API is intended - for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Secret or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.SecretListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("SecretListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_vaults_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_vaults_operations.py deleted file mode 100644 index 710c72d9c145..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/aio/operations/_vaults_operations.py +++ /dev/null @@ -1,1281 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import ( - Any, - AsyncIterable, - AsyncIterator, - Callable, - Dict, - IO, - Literal, - Optional, - Type, - TypeVar, - Union, - cast, - overload, -) -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._vaults_operations import ( - build_check_name_availability_request, - build_create_or_update_request, - build_delete_request, - build_get_deleted_request, - build_get_request, - build_list_by_resource_group_request, - build_list_by_subscription_request, - build_list_deleted_request, - build_list_request, - build_purge_deleted_request, - build_update_access_policy_request, - build_update_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class VaultsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2020_04_01_preview.aio.KeyVaultManagementClient`'s - :attr:`vaults` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - async def _create_or_update_initial( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 201: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultCreateOrUpdateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> AsyncLROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Is either a - VaultCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultCreateOrUpdateParameters - or IO[bytes] - :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._create_or_update_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("Vault", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.Vault].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.Vault]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @overload - async def update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultPatchParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultPatchParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultPatchParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Is either a VaultPatchParameters type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultPatchParameters or - IO[bytes] - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultPatchParameters") - - _request = build_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def delete( # pylint: disable=inconsistent-return-statements - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> None: - """Deletes the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault to delete. Required. - :type vault_name: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - @distributed_trace_async - async def get(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> _models.Vault: - """Gets the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: _models.VaultAccessPolicyParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultAccessPolicyParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: Union[_models.VaultAccessPolicyParameters, IO[bytes]], - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Is either a - VaultAccessPolicyParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultAccessPolicyParameters - or IO[bytes] - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.VaultAccessPolicyParameters] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") - - _request = build_update_access_policy_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - operation_kind=operation_kind, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription and - within the specified resource group. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedVault"]: - """Gets information about the deleted vaults in a subscription. - - :return: An iterator like instance of either DeletedVault or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.DeletedVault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.DeletedVaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("DeletedVaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace_async - async def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _models.DeletedVault: - """Gets the deleted Azure key vault. - - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param location: The location of the deleted vault. Required. - :type location: str - :return: DeletedVault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.DeletedVault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.DeletedVault] = kwargs.pop("cls", None) - - _request = build_get_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("DeletedVault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - async def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_purge_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_purge_deleted(self, vault_name: str, location: str, **kwargs: Any) -> AsyncLROPoller[None]: - """Permanently deletes the specified vault. aka Purges the deleted Azure key vault. - - :param vault_name: The name of the soft-deleted vault. Required. - :type vault_name: str - :param location: The location of the soft-deleted vault. Required. - :type location: str - :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._purge_deleted_initial( - vault_name=vault_name, - location=location, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @overload - async def check_name_availability( - self, - vault_name: _models.VaultCheckNameAvailabilityParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: - ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultCheckNameAvailabilityParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def check_name_availability( - self, vault_name: IO[bytes], *, content_type: str = "application/json", **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def check_name_availability( - self, vault_name: Union[_models.VaultCheckNameAvailabilityParameters, IO[bytes]], **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Is either a VaultCheckNameAvailabilityParameters type - or a IO[bytes] type. Required. - :type vault_name: - ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultCheckNameAvailabilityParameters or - IO[bytes] - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.CheckNameAvailabilityResult] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(vault_name, (IOBase, bytes)): - _content = vault_name - else: - _json = self._serialize.body(vault_name, "VaultCheckNameAvailabilityParameters") - - _request = build_check_name_availability_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/models/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/models/__init__.py deleted file mode 100644 index 8f174a876738..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/models/__init__.py +++ /dev/null @@ -1,175 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._models_py3 import AccessPolicyEntry -from ._models_py3 import Attributes -from ._models_py3 import CheckNameAvailabilityResult -from ._models_py3 import CloudErrorBody -from ._models_py3 import DeletedVault -from ._models_py3 import DeletedVaultListResult -from ._models_py3 import DeletedVaultProperties -from ._models_py3 import DimensionProperties -from ._models_py3 import Error -from ._models_py3 import IPRule -from ._models_py3 import Key -from ._models_py3 import KeyAttributes -from ._models_py3 import KeyCreateParameters -from ._models_py3 import KeyListResult -from ._models_py3 import KeyProperties -from ._models_py3 import LogSpecification -from ._models_py3 import ManagedHsm -from ._models_py3 import ManagedHsmError -from ._models_py3 import ManagedHsmListResult -from ._models_py3 import ManagedHsmProperties -from ._models_py3 import ManagedHsmResource -from ._models_py3 import ManagedHsmSku -from ._models_py3 import MetricSpecification -from ._models_py3 import NetworkRuleSet -from ._models_py3 import Operation -from ._models_py3 import OperationDisplay -from ._models_py3 import OperationListResult -from ._models_py3 import Permissions -from ._models_py3 import PrivateEndpoint -from ._models_py3 import PrivateEndpointConnection -from ._models_py3 import PrivateEndpointConnectionItem -from ._models_py3 import PrivateLinkResource -from ._models_py3 import PrivateLinkResourceListResult -from ._models_py3 import PrivateLinkServiceConnectionState -from ._models_py3 import Resource -from ._models_py3 import ResourceListResult -from ._models_py3 import Secret -from ._models_py3 import SecretAttributes -from ._models_py3 import SecretCreateOrUpdateParameters -from ._models_py3 import SecretListResult -from ._models_py3 import SecretPatchParameters -from ._models_py3 import SecretPatchProperties -from ._models_py3 import SecretProperties -from ._models_py3 import ServiceSpecification -from ._models_py3 import Sku -from ._models_py3 import SystemData -from ._models_py3 import Vault -from ._models_py3 import VaultAccessPolicyParameters -from ._models_py3 import VaultAccessPolicyProperties -from ._models_py3 import VaultCheckNameAvailabilityParameters -from ._models_py3 import VaultCreateOrUpdateParameters -from ._models_py3 import VaultListResult -from ._models_py3 import VaultPatchParameters -from ._models_py3 import VaultPatchProperties -from ._models_py3 import VaultProperties -from ._models_py3 import VirtualNetworkRule - -from ._key_vault_management_client_enums import AccessPolicyUpdateKind -from ._key_vault_management_client_enums import ActionsRequired -from ._key_vault_management_client_enums import CertificatePermissions -from ._key_vault_management_client_enums import CreateMode -from ._key_vault_management_client_enums import DeletionRecoveryLevel -from ._key_vault_management_client_enums import IdentityType -from ._key_vault_management_client_enums import JsonWebKeyCurveName -from ._key_vault_management_client_enums import JsonWebKeyOperation -from ._key_vault_management_client_enums import JsonWebKeyType -from ._key_vault_management_client_enums import KeyPermissions -from ._key_vault_management_client_enums import ManagedHsmSkuFamily -from ._key_vault_management_client_enums import ManagedHsmSkuName -from ._key_vault_management_client_enums import NetworkRuleAction -from ._key_vault_management_client_enums import NetworkRuleBypassOptions -from ._key_vault_management_client_enums import PrivateEndpointConnectionProvisioningState -from ._key_vault_management_client_enums import PrivateEndpointServiceConnectionStatus -from ._key_vault_management_client_enums import ProvisioningState -from ._key_vault_management_client_enums import Reason -from ._key_vault_management_client_enums import SecretPermissions -from ._key_vault_management_client_enums import SkuFamily -from ._key_vault_management_client_enums import SkuName -from ._key_vault_management_client_enums import StoragePermissions -from ._key_vault_management_client_enums import VaultProvisioningState -from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "AccessPolicyEntry", - "Attributes", - "CheckNameAvailabilityResult", - "CloudErrorBody", - "DeletedVault", - "DeletedVaultListResult", - "DeletedVaultProperties", - "DimensionProperties", - "Error", - "IPRule", - "Key", - "KeyAttributes", - "KeyCreateParameters", - "KeyListResult", - "KeyProperties", - "LogSpecification", - "ManagedHsm", - "ManagedHsmError", - "ManagedHsmListResult", - "ManagedHsmProperties", - "ManagedHsmResource", - "ManagedHsmSku", - "MetricSpecification", - "NetworkRuleSet", - "Operation", - "OperationDisplay", - "OperationListResult", - "Permissions", - "PrivateEndpoint", - "PrivateEndpointConnection", - "PrivateEndpointConnectionItem", - "PrivateLinkResource", - "PrivateLinkResourceListResult", - "PrivateLinkServiceConnectionState", - "Resource", - "ResourceListResult", - "Secret", - "SecretAttributes", - "SecretCreateOrUpdateParameters", - "SecretListResult", - "SecretPatchParameters", - "SecretPatchProperties", - "SecretProperties", - "ServiceSpecification", - "Sku", - "SystemData", - "Vault", - "VaultAccessPolicyParameters", - "VaultAccessPolicyProperties", - "VaultCheckNameAvailabilityParameters", - "VaultCreateOrUpdateParameters", - "VaultListResult", - "VaultPatchParameters", - "VaultPatchProperties", - "VaultProperties", - "VirtualNetworkRule", - "AccessPolicyUpdateKind", - "ActionsRequired", - "CertificatePermissions", - "CreateMode", - "DeletionRecoveryLevel", - "IdentityType", - "JsonWebKeyCurveName", - "JsonWebKeyOperation", - "JsonWebKeyType", - "KeyPermissions", - "ManagedHsmSkuFamily", - "ManagedHsmSkuName", - "NetworkRuleAction", - "NetworkRuleBypassOptions", - "PrivateEndpointConnectionProvisioningState", - "PrivateEndpointServiceConnectionStatus", - "ProvisioningState", - "Reason", - "SecretPermissions", - "SkuFamily", - "SkuName", - "StoragePermissions", - "VaultProvisioningState", -] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/models/_key_vault_management_client_enums.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/models/_key_vault_management_client_enums.py deleted file mode 100644 index 6f3a724c6688..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/models/_key_vault_management_client_enums.py +++ /dev/null @@ -1,262 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from enum import Enum -from azure.core import CaseInsensitiveEnumMeta - - -class AccessPolicyUpdateKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """AccessPolicyUpdateKind.""" - - ADD = "add" - REPLACE = "replace" - REMOVE = "remove" - - -class ActionsRequired(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """A message indicating if changes on the service provider require any updates on the consumer.""" - - NONE = "None" - - -class CertificatePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """CertificatePermissions.""" - - GET = "get" - LIST = "list" - DELETE = "delete" - CREATE = "create" - IMPORT = "import" - UPDATE = "update" - MANAGECONTACTS = "managecontacts" - GETISSUERS = "getissuers" - LISTISSUERS = "listissuers" - SETISSUERS = "setissuers" - DELETEISSUERS = "deleteissuers" - MANAGEISSUERS = "manageissuers" - RECOVER = "recover" - PURGE = "purge" - BACKUP = "backup" - RESTORE = "restore" - IMPORT_ENUM = "import" - - -class CreateMode(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The vault's create mode to indicate whether the vault need to be recovered or not.""" - - RECOVER = "recover" - DEFAULT = "default" - - -class DeletionRecoveryLevel(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The deletion recovery level currently in effect for the object. If it contains 'Purgeable', - then the object can be permanently deleted by a privileged user; otherwise, only the system can - purge the object at the end of the retention interval. - """ - - PURGEABLE = "Purgeable" - RECOVERABLE_PURGEABLE = "Recoverable+Purgeable" - RECOVERABLE = "Recoverable" - RECOVERABLE_PROTECTED_SUBSCRIPTION = "Recoverable+ProtectedSubscription" - - -class IdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of identity.""" - - USER = "User" - APPLICATION = "Application" - MANAGED_IDENTITY = "ManagedIdentity" - KEY = "Key" - - -class JsonWebKeyCurveName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The elliptic curve name. For valid values, see JsonWebKeyCurveName.""" - - P256 = "P-256" - P384 = "P-384" - P521 = "P-521" - P256_K = "P-256K" - - -class JsonWebKeyOperation(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The permitted JSON web key operations of the key. For more information, see - JsonWebKeyOperation. - """ - - ENCRYPT = "encrypt" - DECRYPT = "decrypt" - SIGN = "sign" - VERIFY = "verify" - WRAP_KEY = "wrapKey" - UNWRAP_KEY = "unwrapKey" - IMPORT = "import" - IMPORT_ENUM = "import" - - -class JsonWebKeyType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of the key. For valid values, see JsonWebKeyType.""" - - EC = "EC" - EC_HSM = "EC-HSM" - RSA = "RSA" - RSA_HSM = "RSA-HSM" - - -class KeyPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """KeyPermissions.""" - - ENCRYPT = "encrypt" - DECRYPT = "decrypt" - WRAP_KEY = "wrapKey" - UNWRAP_KEY = "unwrapKey" - SIGN = "sign" - VERIFY = "verify" - GET = "get" - LIST = "list" - CREATE = "create" - UPDATE = "update" - IMPORT = "import" - DELETE = "delete" - BACKUP = "backup" - RESTORE = "restore" - RECOVER = "recover" - PURGE = "purge" - IMPORT_ENUM = "import" - - -class ManagedHsmSkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU Family of the managed HSM Pool.""" - - B = "B" - - -class ManagedHsmSkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU of the managed HSM Pool.""" - - STANDARD_B1 = "Standard_B1" - CUSTOM_B32 = "Custom_B32" - - -class NetworkRuleAction(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The default action when no rule from ipRules and from virtualNetworkRules match. This is only - used after the bypass property has been evaluated. - """ - - ALLOW = "Allow" - DENY = "Deny" - - -class NetworkRuleBypassOptions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Tells what traffic can bypass network rules. This can be 'AzureServices' or 'None'. If not - specified the default is 'AzureServices'. - """ - - AZURE_SERVICES = "AzureServices" - NONE = "None" - - -class PrivateEndpointConnectionProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The current provisioning state.""" - - SUCCEEDED = "Succeeded" - CREATING = "Creating" - UPDATING = "Updating" - DELETING = "Deleting" - FAILED = "Failed" - DISCONNECTED = "Disconnected" - - -class PrivateEndpointServiceConnectionStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The private endpoint connection status.""" - - PENDING = "Pending" - APPROVED = "Approved" - REJECTED = "Rejected" - DISCONNECTED = "Disconnected" - - -class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Provisioning state.""" - - SUCCEEDED = "Succeeded" - """The managed HSM Pool has been full provisioned.""" - PROVISIONING = "Provisioning" - """The managed HSM Pool is currently being provisioned.""" - FAILED = "Failed" - """Provisioning of the managed HSM Pool has failed.""" - UPDATING = "Updating" - """The managed HSM Pool is currently being updated.""" - DELETING = "Deleting" - """The managed HSM Pool is currently being deleted.""" - ACTIVATED = "Activated" - """The managed HSM pool is ready for normal use.""" - SECURITY_DOMAIN_RESTORE = "SecurityDomainRestore" - """The managed HSM pool is waiting for a security domain restore action.""" - RESTORING = "Restoring" - """The managed HSM pool is being restored from full HSM backup.""" - - -class Reason(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The reason that a vault name could not be used. The Reason element is only returned if - NameAvailable is false. - """ - - ACCOUNT_NAME_INVALID = "AccountNameInvalid" - ALREADY_EXISTS = "AlreadyExists" - - -class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SecretPermissions.""" - - GET = "get" - LIST = "list" - SET = "set" - DELETE = "delete" - BACKUP = "backup" - RESTORE = "restore" - RECOVER = "recover" - PURGE = "purge" - - -class SkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU family name.""" - - A = "A" - - -class SkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU name to specify whether the key vault is a standard vault or a premium vault.""" - - STANDARD = "standard" - PREMIUM = "premium" - - -class StoragePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """StoragePermissions.""" - - GET = "get" - LIST = "list" - DELETE = "delete" - SET = "set" - UPDATE = "update" - REGENERATEKEY = "regeneratekey" - RECOVER = "recover" - PURGE = "purge" - BACKUP = "backup" - RESTORE = "restore" - SETSAS = "setsas" - LISTSAS = "listsas" - GETSAS = "getsas" - DELETESAS = "deletesas" - - -class VaultProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Provisioning state of the vault.""" - - SUCCEEDED = "Succeeded" - REGISTERING_DNS = "RegisteringDns" diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/models/_models_py3.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/models/_models_py3.py deleted file mode 100644 index 27e86b5dd8ba..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/models/_models_py3.py +++ /dev/null @@ -1,2808 +0,0 @@ -# coding=utf-8 -# pylint: disable=too-many-lines -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -import datetime -from typing import Any, Dict, List, Optional, TYPE_CHECKING, Union - -from ... import _serialization - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from .. import models as _models - - -class AccessPolicyEntry(_serialization.Model): - """An identity that have access to the key vault. All identities in the array must use the same - tenant ID as the key vault's tenant ID. - - All required parameters must be populated in order to send to server. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :vartype tenant_id: str - :ivar object_id: The object ID of a user, service principal or security group in the Azure - Active Directory tenant for the vault. The object ID must be unique for the list of access - policies. Required. - :vartype object_id: str - :ivar application_id: Application ID of the client making request on behalf of a principal. - :vartype application_id: str - :ivar permissions: Permissions the identity has for keys, secrets and certificates. Required. - :vartype permissions: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Permissions - """ - - _validation = { - "tenant_id": {"required": True}, - "object_id": {"required": True}, - "permissions": {"required": True}, - } - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "object_id": {"key": "objectId", "type": "str"}, - "application_id": {"key": "applicationId", "type": "str"}, - "permissions": {"key": "permissions", "type": "Permissions"}, - } - - def __init__( - self, - *, - tenant_id: str, - object_id: str, - permissions: "_models.Permissions", - application_id: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :paramtype tenant_id: str - :keyword object_id: The object ID of a user, service principal or security group in the Azure - Active Directory tenant for the vault. The object ID must be unique for the list of access - policies. Required. - :paramtype object_id: str - :keyword application_id: Application ID of the client making request on behalf of a principal. - :paramtype application_id: str - :keyword permissions: Permissions the identity has for keys, secrets and certificates. - Required. - :paramtype permissions: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Permissions - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.object_id = object_id - self.application_id = application_id - self.permissions = permissions - - -class Attributes(_serialization.Model): - """The object attributes managed by the KeyVault service. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar enabled: Determines whether the object is enabled. - :vartype enabled: bool - :ivar not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :vartype not_before: ~datetime.datetime - :ivar expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :vartype expires: ~datetime.datetime - :ivar created: Creation time in seconds since 1970-01-01T00:00:00Z. - :vartype created: ~datetime.datetime - :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: ~datetime.datetime - """ - - _validation = { - "created": {"readonly": True}, - "updated": {"readonly": True}, - } - - _attribute_map = { - "enabled": {"key": "enabled", "type": "bool"}, - "not_before": {"key": "nbf", "type": "unix-time"}, - "expires": {"key": "exp", "type": "unix-time"}, - "created": {"key": "created", "type": "unix-time"}, - "updated": {"key": "updated", "type": "unix-time"}, - } - - def __init__( - self, - *, - enabled: Optional[bool] = None, - not_before: Optional[datetime.datetime] = None, - expires: Optional[datetime.datetime] = None, - **kwargs: Any - ) -> None: - """ - :keyword enabled: Determines whether the object is enabled. - :paramtype enabled: bool - :keyword not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :paramtype not_before: ~datetime.datetime - :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :paramtype expires: ~datetime.datetime - """ - super().__init__(**kwargs) - self.enabled = enabled - self.not_before = not_before - self.expires = expires - self.created = None - self.updated = None - - -class CheckNameAvailabilityResult(_serialization.Model): - """The CheckNameAvailability operation response. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar name_available: A boolean value that indicates whether the name is available for you to - use. If true, the name is available. If false, the name has already been taken or is invalid - and cannot be used. - :vartype name_available: bool - :ivar reason: The reason that a vault name could not be used. The Reason element is only - returned if NameAvailable is false. Known values are: "AccountNameInvalid" and "AlreadyExists". - :vartype reason: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.Reason - :ivar message: An error message explaining the Reason value in more detail. - :vartype message: str - """ - - _validation = { - "name_available": {"readonly": True}, - "reason": {"readonly": True}, - "message": {"readonly": True}, - } - - _attribute_map = { - "name_available": {"key": "nameAvailable", "type": "bool"}, - "reason": {"key": "reason", "type": "str"}, - "message": {"key": "message", "type": "str"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.name_available = None - self.reason = None - self.message = None - - -class CloudErrorBody(_serialization.Model): - """An error response from Key Vault resource provider. - - :ivar code: Error code. This is a mnemonic that can be consumed programmatically. - :vartype code: str - :ivar message: User friendly error message. The message is typically localized and may vary - with service version. - :vartype message: str - """ - - _attribute_map = { - "code": {"key": "code", "type": "str"}, - "message": {"key": "message", "type": "str"}, - } - - def __init__(self, *, code: Optional[str] = None, message: Optional[str] = None, **kwargs: Any) -> None: - """ - :keyword code: Error code. This is a mnemonic that can be consumed programmatically. - :paramtype code: str - :keyword message: User friendly error message. The message is typically localized and may vary - with service version. - :paramtype message: str - """ - super().__init__(**kwargs) - self.code = code - self.message = message - - -class DeletedVault(_serialization.Model): - """Deleted vault information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The resource ID for the deleted key vault. - :vartype id: str - :ivar name: The name of the key vault. - :vartype name: str - :ivar type: The resource type of the key vault. - :vartype type: str - :ivar properties: Properties of the vault. - :vartype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.DeletedVaultProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "properties": {"key": "properties", "type": "DeletedVaultProperties"}, - } - - def __init__(self, *, properties: Optional["_models.DeletedVaultProperties"] = None, **kwargs: Any) -> None: - """ - :keyword properties: Properties of the vault. - :paramtype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.DeletedVaultProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.properties = properties - - -class DeletedVaultListResult(_serialization.Model): - """List of vaults. - - :ivar value: The list of deleted vaults. - :vartype value: list[~azure.mgmt.keyvault.v2020_04_01_preview.models.DeletedVault] - :ivar next_link: The URL to get the next set of deleted vaults. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[DeletedVault]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.DeletedVault"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of deleted vaults. - :paramtype value: list[~azure.mgmt.keyvault.v2020_04_01_preview.models.DeletedVault] - :keyword next_link: The URL to get the next set of deleted vaults. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class DeletedVaultProperties(_serialization.Model): - """Properties of the deleted vault. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar vault_id: The resource id of the original vault. - :vartype vault_id: str - :ivar location: The location of the original vault. - :vartype location: str - :ivar deletion_date: The deleted date. - :vartype deletion_date: ~datetime.datetime - :ivar scheduled_purge_date: The scheduled purged date. - :vartype scheduled_purge_date: ~datetime.datetime - :ivar tags: Tags of the original vault. - :vartype tags: dict[str, str] - :ivar purge_protection_enabled: Purge protection status of the original vault. - :vartype purge_protection_enabled: bool - """ - - _validation = { - "vault_id": {"readonly": True}, - "location": {"readonly": True}, - "deletion_date": {"readonly": True}, - "scheduled_purge_date": {"readonly": True}, - "tags": {"readonly": True}, - "purge_protection_enabled": {"readonly": True}, - } - - _attribute_map = { - "vault_id": {"key": "vaultId", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "deletion_date": {"key": "deletionDate", "type": "iso-8601"}, - "scheduled_purge_date": {"key": "scheduledPurgeDate", "type": "iso-8601"}, - "tags": {"key": "tags", "type": "{str}"}, - "purge_protection_enabled": {"key": "purgeProtectionEnabled", "type": "bool"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.vault_id = None - self.location = None - self.deletion_date = None - self.scheduled_purge_date = None - self.tags = None - self.purge_protection_enabled = None - - -class DimensionProperties(_serialization.Model): - """Type of operation: get, read, delete, etc. - - :ivar name: Name of dimension. - :vartype name: str - :ivar display_name: Display name of dimension. - :vartype display_name: str - :ivar to_be_exported_for_shoebox: Property to specify whether the dimension should be exported - for shoebox. - :vartype to_be_exported_for_shoebox: bool - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display_name": {"key": "displayName", "type": "str"}, - "to_be_exported_for_shoebox": {"key": "toBeExportedForShoebox", "type": "bool"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display_name: Optional[str] = None, - to_be_exported_for_shoebox: Optional[bool] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Name of dimension. - :paramtype name: str - :keyword display_name: Display name of dimension. - :paramtype display_name: str - :keyword to_be_exported_for_shoebox: Property to specify whether the dimension should be - exported for shoebox. - :paramtype to_be_exported_for_shoebox: bool - """ - super().__init__(**kwargs) - self.name = name - self.display_name = display_name - self.to_be_exported_for_shoebox = to_be_exported_for_shoebox - - -class Error(_serialization.Model): - """The server error. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar code: The error code. - :vartype code: str - :ivar message: The error message. - :vartype message: str - :ivar inner_error: The inner error, contains a more specific error code. - :vartype inner_error: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Error - """ - - _validation = { - "code": {"readonly": True}, - "message": {"readonly": True}, - "inner_error": {"readonly": True}, - } - - _attribute_map = { - "code": {"key": "code", "type": "str"}, - "message": {"key": "message", "type": "str"}, - "inner_error": {"key": "innererror", "type": "Error"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.code = None - self.message = None - self.inner_error = None - - -class IPRule(_serialization.Model): - """A rule governing the accessibility of a vault from a specific ip address or ip range. - - All required parameters must be populated in order to send to server. - - :ivar value: An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP address) - or '124.56.78.0/24' (all addresses that start with 124.56.78). Required. - :vartype value: str - """ - - _validation = { - "value": {"required": True}, - } - - _attribute_map = { - "value": {"key": "value", "type": "str"}, - } - - def __init__(self, *, value: str, **kwargs: Any) -> None: - """ - :keyword value: An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP - address) or '124.56.78.0/24' (all addresses that start with 124.56.78). Required. - :paramtype value: str - """ - super().__init__(**kwargs) - self.value = value - - -class Resource(_serialization.Model): - """Key Vault resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = None - self.tags = None - - -class Key(Resource): # pylint: disable=too-many-instance-attributes - """The key resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar attributes: The attributes of the key. - :vartype attributes: ~azure.mgmt.keyvault.v2020_04_01_preview.models.KeyAttributes - :ivar kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: "EC", - "EC-HSM", "RSA", and "RSA-HSM". - :vartype kty: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.JsonWebKeyType - :ivar key_ops: - :vartype key_ops: list[str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.JsonWebKeyOperation] - :ivar key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. - :vartype key_size: int - :ivar curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :vartype curve_name: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.JsonWebKeyCurveName - :ivar key_uri: The URI to retrieve the current version of the key. - :vartype key_uri: str - :ivar key_uri_with_version: The URI to retrieve the specific version of the key. - :vartype key_uri_with_version: str - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - "key_uri": {"readonly": True}, - "key_uri_with_version": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "attributes": {"key": "properties.attributes", "type": "KeyAttributes"}, - "kty": {"key": "properties.kty", "type": "str"}, - "key_ops": {"key": "properties.keyOps", "type": "[str]"}, - "key_size": {"key": "properties.keySize", "type": "int"}, - "curve_name": {"key": "properties.curveName", "type": "str"}, - "key_uri": {"key": "properties.keyUri", "type": "str"}, - "key_uri_with_version": {"key": "properties.keyUriWithVersion", "type": "str"}, - } - - def __init__( - self, - *, - attributes: Optional["_models.KeyAttributes"] = None, - kty: Optional[Union[str, "_models.JsonWebKeyType"]] = None, - key_ops: Optional[List[Union[str, "_models.JsonWebKeyOperation"]]] = None, - key_size: Optional[int] = None, - curve_name: Optional[Union[str, "_models.JsonWebKeyCurveName"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword attributes: The attributes of the key. - :paramtype attributes: ~azure.mgmt.keyvault.v2020_04_01_preview.models.KeyAttributes - :keyword kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: - "EC", "EC-HSM", "RSA", and "RSA-HSM". - :paramtype kty: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.JsonWebKeyType - :keyword key_ops: - :paramtype key_ops: list[str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.JsonWebKeyOperation] - :keyword key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. - :paramtype key_size: int - :keyword curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :paramtype curve_name: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.JsonWebKeyCurveName - """ - super().__init__(**kwargs) - self.attributes = attributes - self.kty = kty - self.key_ops = key_ops - self.key_size = key_size - self.curve_name = curve_name - self.key_uri = None - self.key_uri_with_version = None - - -class KeyAttributes(_serialization.Model): - """The attributes of the key. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar enabled: Determines whether or not the object is enabled. - :vartype enabled: bool - :ivar not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :vartype not_before: int - :ivar expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :vartype expires: int - :ivar created: Creation time in seconds since 1970-01-01T00:00:00Z. - :vartype created: int - :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: int - :ivar recovery_level: The deletion recovery level currently in effect for the object. If it - contains 'Purgeable', then the object can be permanently deleted by a privileged user; - otherwise, only the system can purge the object at the end of the retention interval. Known - values are: "Purgeable", "Recoverable+Purgeable", "Recoverable", and - "Recoverable+ProtectedSubscription". - :vartype recovery_level: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.DeletionRecoveryLevel - """ - - _validation = { - "created": {"readonly": True}, - "updated": {"readonly": True}, - "recovery_level": {"readonly": True}, - } - - _attribute_map = { - "enabled": {"key": "enabled", "type": "bool"}, - "not_before": {"key": "nbf", "type": "int"}, - "expires": {"key": "exp", "type": "int"}, - "created": {"key": "created", "type": "int"}, - "updated": {"key": "updated", "type": "int"}, - "recovery_level": {"key": "recoveryLevel", "type": "str"}, - } - - def __init__( - self, - *, - enabled: Optional[bool] = None, - not_before: Optional[int] = None, - expires: Optional[int] = None, - **kwargs: Any - ) -> None: - """ - :keyword enabled: Determines whether or not the object is enabled. - :paramtype enabled: bool - :keyword not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :paramtype not_before: int - :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :paramtype expires: int - """ - super().__init__(**kwargs) - self.enabled = enabled - self.not_before = not_before - self.expires = expires - self.created = None - self.updated = None - self.recovery_level = None - - -class KeyCreateParameters(_serialization.Model): - """The parameters used to create a key. - - All required parameters must be populated in order to send to server. - - :ivar tags: The tags that will be assigned to the key. - :vartype tags: dict[str, str] - :ivar properties: The properties of the key to be created. Required. - :vartype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.KeyProperties - """ - - _validation = { - "properties": {"required": True}, - } - - _attribute_map = { - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "KeyProperties"}, - } - - def __init__( - self, *, properties: "_models.KeyProperties", tags: Optional[Dict[str, str]] = None, **kwargs: Any - ) -> None: - """ - :keyword tags: The tags that will be assigned to the key. - :paramtype tags: dict[str, str] - :keyword properties: The properties of the key to be created. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.KeyProperties - """ - super().__init__(**kwargs) - self.tags = tags - self.properties = properties - - -class KeyListResult(_serialization.Model): - """The page of keys. - - :ivar value: The key resources. - :vartype value: list[~azure.mgmt.keyvault.v2020_04_01_preview.models.Key] - :ivar next_link: The URL to get the next page of keys. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Key]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Key"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The key resources. - :paramtype value: list[~azure.mgmt.keyvault.v2020_04_01_preview.models.Key] - :keyword next_link: The URL to get the next page of keys. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class KeyProperties(_serialization.Model): - """The properties of the key. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar attributes: The attributes of the key. - :vartype attributes: ~azure.mgmt.keyvault.v2020_04_01_preview.models.KeyAttributes - :ivar kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: "EC", - "EC-HSM", "RSA", and "RSA-HSM". - :vartype kty: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.JsonWebKeyType - :ivar key_ops: - :vartype key_ops: list[str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.JsonWebKeyOperation] - :ivar key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. - :vartype key_size: int - :ivar curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :vartype curve_name: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.JsonWebKeyCurveName - :ivar key_uri: The URI to retrieve the current version of the key. - :vartype key_uri: str - :ivar key_uri_with_version: The URI to retrieve the specific version of the key. - :vartype key_uri_with_version: str - """ - - _validation = { - "key_uri": {"readonly": True}, - "key_uri_with_version": {"readonly": True}, - } - - _attribute_map = { - "attributes": {"key": "attributes", "type": "KeyAttributes"}, - "kty": {"key": "kty", "type": "str"}, - "key_ops": {"key": "keyOps", "type": "[str]"}, - "key_size": {"key": "keySize", "type": "int"}, - "curve_name": {"key": "curveName", "type": "str"}, - "key_uri": {"key": "keyUri", "type": "str"}, - "key_uri_with_version": {"key": "keyUriWithVersion", "type": "str"}, - } - - def __init__( - self, - *, - attributes: Optional["_models.KeyAttributes"] = None, - kty: Optional[Union[str, "_models.JsonWebKeyType"]] = None, - key_ops: Optional[List[Union[str, "_models.JsonWebKeyOperation"]]] = None, - key_size: Optional[int] = None, - curve_name: Optional[Union[str, "_models.JsonWebKeyCurveName"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword attributes: The attributes of the key. - :paramtype attributes: ~azure.mgmt.keyvault.v2020_04_01_preview.models.KeyAttributes - :keyword kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: - "EC", "EC-HSM", "RSA", and "RSA-HSM". - :paramtype kty: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.JsonWebKeyType - :keyword key_ops: - :paramtype key_ops: list[str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.JsonWebKeyOperation] - :keyword key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. - :paramtype key_size: int - :keyword curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :paramtype curve_name: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.JsonWebKeyCurveName - """ - super().__init__(**kwargs) - self.attributes = attributes - self.kty = kty - self.key_ops = key_ops - self.key_size = key_size - self.curve_name = curve_name - self.key_uri = None - self.key_uri_with_version = None - - -class LogSpecification(_serialization.Model): - """Log specification of operation. - - :ivar name: Name of log specification. - :vartype name: str - :ivar display_name: Display name of log specification. - :vartype display_name: str - :ivar blob_duration: Blob duration of specification. - :vartype blob_duration: str - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display_name": {"key": "displayName", "type": "str"}, - "blob_duration": {"key": "blobDuration", "type": "str"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display_name: Optional[str] = None, - blob_duration: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Name of log specification. - :paramtype name: str - :keyword display_name: Display name of log specification. - :paramtype display_name: str - :keyword blob_duration: Blob duration of specification. - :paramtype blob_duration: str - """ - super().__init__(**kwargs) - self.name = name - self.display_name = display_name - self.blob_duration = blob_duration - - -class ManagedHsmResource(_serialization.Model): - """Managed HSM resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The Azure Resource Manager resource ID for the managed HSM Pool. - :vartype id: str - :ivar name: The name of the managed HSM Pool. - :vartype name: str - :ivar type: The resource type of the managed HSM Pool. - :vartype type: str - :ivar location: The supported Azure location where the managed HSM Pool should be created. - :vartype location: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsmSku - :ivar tags: Resource tags. - :vartype tags: dict[str, str] - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "sku": {"key": "sku", "type": "ManagedHsmSku"}, - "tags": {"key": "tags", "type": "{str}"}, - } - - def __init__( - self, - *, - location: Optional[str] = None, - sku: Optional["_models.ManagedHsmSku"] = None, - tags: Optional[Dict[str, str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the managed HSM Pool should be created. - :paramtype location: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsmSku - :keyword tags: Resource tags. - :paramtype tags: dict[str, str] - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = location - self.sku = sku - self.tags = tags - - -class ManagedHsm(ManagedHsmResource): - """Resource information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The Azure Resource Manager resource ID for the managed HSM Pool. - :vartype id: str - :ivar name: The name of the managed HSM Pool. - :vartype name: str - :ivar type: The resource type of the managed HSM Pool. - :vartype type: str - :ivar location: The supported Azure location where the managed HSM Pool should be created. - :vartype location: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsmSku - :ivar tags: Resource tags. - :vartype tags: dict[str, str] - :ivar properties: Properties of the managed HSM. - :vartype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsmProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "sku": {"key": "sku", "type": "ManagedHsmSku"}, - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "ManagedHsmProperties"}, - } - - def __init__( - self, - *, - location: Optional[str] = None, - sku: Optional["_models.ManagedHsmSku"] = None, - tags: Optional[Dict[str, str]] = None, - properties: Optional["_models.ManagedHsmProperties"] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the managed HSM Pool should be created. - :paramtype location: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsmSku - :keyword tags: Resource tags. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the managed HSM. - :paramtype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsmProperties - """ - super().__init__(location=location, sku=sku, tags=tags, **kwargs) - self.properties = properties - - -class ManagedHsmError(_serialization.Model): - """The error exception. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar error: The server error. - :vartype error: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Error - """ - - _validation = { - "error": {"readonly": True}, - } - - _attribute_map = { - "error": {"key": "error", "type": "Error"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.error = None - - -class ManagedHsmListResult(_serialization.Model): - """List of managed HSM Pools. - - :ivar value: The list of managed HSM Pools. - :vartype value: list[~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm] - :ivar next_link: The URL to get the next set of managed HSM Pools. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[ManagedHsm]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.ManagedHsm"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of managed HSM Pools. - :paramtype value: list[~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm] - :keyword next_link: The URL to get the next set of managed HSM Pools. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class ManagedHsmProperties(_serialization.Model): - """Properties of the managed HSM Pool. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the managed HSM pool. - :vartype tenant_id: str - :ivar initial_admin_object_ids: Array of initial administrators object ids for this managed hsm - pool. - :vartype initial_admin_object_ids: list[str] - :ivar hsm_uri: The URI of the managed hsm pool for performing operations on keys. - :vartype hsm_uri: str - :ivar enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this managed HSM pool. Soft delete is enabled by default for all managed HSMs and - is immutable. - :vartype enable_soft_delete: bool - :ivar soft_delete_retention_in_days: Soft deleted data retention days. When you delete an HSM - or a key, it will remain recoverable for the configured retention period or for a default - period of 90 days. It accepts values between 7 and 90. - :vartype soft_delete_retention_in_days: int - :ivar enable_purge_protection: Property specifying whether protection against purge is enabled - for this managed HSM pool. Setting this property to true activates protection against purge for - this managed HSM pool and its content - only the Managed HSM service may initiate a hard, - irrecoverable deletion. Enabling this functionality is irreversible. - :vartype enable_purge_protection: bool - :ivar create_mode: The create mode to indicate whether the resource is being created or is - being recovered from a deleted resource. Known values are: "recover" and "default". - :vartype create_mode: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.CreateMode - :ivar status_message: Resource Status Message. - :vartype status_message: str - :ivar provisioning_state: Provisioning state. Known values are: "Succeeded", "Provisioning", - "Failed", "Updating", "Deleting", "Activated", "SecurityDomainRestore", and "Restoring". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.ProvisioningState - """ - - _validation = { - "hsm_uri": {"readonly": True}, - "status_message": {"readonly": True}, - "provisioning_state": {"readonly": True}, - } - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "initial_admin_object_ids": {"key": "initialAdminObjectIds", "type": "[str]"}, - "hsm_uri": {"key": "hsmUri", "type": "str"}, - "enable_soft_delete": {"key": "enableSoftDelete", "type": "bool"}, - "soft_delete_retention_in_days": {"key": "softDeleteRetentionInDays", "type": "int"}, - "enable_purge_protection": {"key": "enablePurgeProtection", "type": "bool"}, - "create_mode": {"key": "createMode", "type": "str"}, - "status_message": {"key": "statusMessage", "type": "str"}, - "provisioning_state": {"key": "provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - tenant_id: Optional[str] = None, - initial_admin_object_ids: Optional[List[str]] = None, - enable_soft_delete: bool = True, - soft_delete_retention_in_days: int = 90, - enable_purge_protection: bool = True, - create_mode: Optional[Union[str, "_models.CreateMode"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the managed HSM pool. - :paramtype tenant_id: str - :keyword initial_admin_object_ids: Array of initial administrators object ids for this managed - hsm pool. - :paramtype initial_admin_object_ids: list[str] - :keyword enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this managed HSM pool. Soft delete is enabled by default for all managed HSMs and - is immutable. - :paramtype enable_soft_delete: bool - :keyword soft_delete_retention_in_days: Soft deleted data retention days. When you delete an - HSM or a key, it will remain recoverable for the configured retention period or for a default - period of 90 days. It accepts values between 7 and 90. - :paramtype soft_delete_retention_in_days: int - :keyword enable_purge_protection: Property specifying whether protection against purge is - enabled for this managed HSM pool. Setting this property to true activates protection against - purge for this managed HSM pool and its content - only the Managed HSM service may initiate a - hard, irrecoverable deletion. Enabling this functionality is irreversible. - :paramtype enable_purge_protection: bool - :keyword create_mode: The create mode to indicate whether the resource is being created or is - being recovered from a deleted resource. Known values are: "recover" and "default". - :paramtype create_mode: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.CreateMode - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.initial_admin_object_ids = initial_admin_object_ids - self.hsm_uri = None - self.enable_soft_delete = enable_soft_delete - self.soft_delete_retention_in_days = soft_delete_retention_in_days - self.enable_purge_protection = enable_purge_protection - self.create_mode = create_mode - self.status_message = None - self.provisioning_state = None - - -class ManagedHsmSku(_serialization.Model): - """SKU details. - - All required parameters must be populated in order to send to server. - - :ivar family: SKU Family of the managed HSM Pool. "B" - :vartype family: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsmSkuFamily - :ivar name: SKU of the managed HSM Pool. Required. Known values are: "Standard_B1" and - "Custom_B32". - :vartype name: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsmSkuName - """ - - _validation = { - "family": {"required": True}, - "name": {"required": True}, - } - - _attribute_map = { - "family": {"key": "family", "type": "str"}, - "name": {"key": "name", "type": "str"}, - } - - def __init__( - self, - *, - family: Union[str, "_models.ManagedHsmSkuFamily"] = "B", - name: Union[str, "_models.ManagedHsmSkuName"], - **kwargs: Any - ) -> None: - """ - :keyword family: SKU Family of the managed HSM Pool. "B" - :paramtype family: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsmSkuFamily - :keyword name: SKU of the managed HSM Pool. Required. Known values are: "Standard_B1" and - "Custom_B32". - :paramtype name: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsmSkuName - """ - super().__init__(**kwargs) - self.family = family - self.name = name - - -class MetricSpecification(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Metric specification of operation. - - :ivar name: Name of metric specification. - :vartype name: str - :ivar display_name: Display name of Metric specification. - :vartype display_name: str - :ivar display_description: Display description of Metric specification. - :vartype display_description: str - :ivar unit: The metric unit. Possible values include: 'Bytes', 'Count', 'Milliseconds'. - :vartype unit: str - :ivar aggregation_type: The metric aggregation type. Possible values include: 'Average', - 'Count', 'Total'. - :vartype aggregation_type: str - :ivar supported_aggregation_types: The supported aggregation types for the metrics. - :vartype supported_aggregation_types: list[str] - :ivar supported_time_grain_types: The supported time grain types for the metrics. - :vartype supported_time_grain_types: list[str] - :ivar lock_aggregation_type: The metric lock aggregation type. - :vartype lock_aggregation_type: str - :ivar dimensions: The dimensions of metric. - :vartype dimensions: list[~azure.mgmt.keyvault.v2020_04_01_preview.models.DimensionProperties] - :ivar fill_gap_with_zero: Property to specify whether to fill gap with zero. - :vartype fill_gap_with_zero: bool - :ivar internal_metric_name: The internal metric name. - :vartype internal_metric_name: str - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display_name": {"key": "displayName", "type": "str"}, - "display_description": {"key": "displayDescription", "type": "str"}, - "unit": {"key": "unit", "type": "str"}, - "aggregation_type": {"key": "aggregationType", "type": "str"}, - "supported_aggregation_types": {"key": "supportedAggregationTypes", "type": "[str]"}, - "supported_time_grain_types": {"key": "supportedTimeGrainTypes", "type": "[str]"}, - "lock_aggregation_type": {"key": "lockAggregationType", "type": "str"}, - "dimensions": {"key": "dimensions", "type": "[DimensionProperties]"}, - "fill_gap_with_zero": {"key": "fillGapWithZero", "type": "bool"}, - "internal_metric_name": {"key": "internalMetricName", "type": "str"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display_name: Optional[str] = None, - display_description: Optional[str] = None, - unit: Optional[str] = None, - aggregation_type: Optional[str] = None, - supported_aggregation_types: Optional[List[str]] = None, - supported_time_grain_types: Optional[List[str]] = None, - lock_aggregation_type: Optional[str] = None, - dimensions: Optional[List["_models.DimensionProperties"]] = None, - fill_gap_with_zero: Optional[bool] = None, - internal_metric_name: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Name of metric specification. - :paramtype name: str - :keyword display_name: Display name of Metric specification. - :paramtype display_name: str - :keyword display_description: Display description of Metric specification. - :paramtype display_description: str - :keyword unit: The metric unit. Possible values include: 'Bytes', 'Count', 'Milliseconds'. - :paramtype unit: str - :keyword aggregation_type: The metric aggregation type. Possible values include: 'Average', - 'Count', 'Total'. - :paramtype aggregation_type: str - :keyword supported_aggregation_types: The supported aggregation types for the metrics. - :paramtype supported_aggregation_types: list[str] - :keyword supported_time_grain_types: The supported time grain types for the metrics. - :paramtype supported_time_grain_types: list[str] - :keyword lock_aggregation_type: The metric lock aggregation type. - :paramtype lock_aggregation_type: str - :keyword dimensions: The dimensions of metric. - :paramtype dimensions: - list[~azure.mgmt.keyvault.v2020_04_01_preview.models.DimensionProperties] - :keyword fill_gap_with_zero: Property to specify whether to fill gap with zero. - :paramtype fill_gap_with_zero: bool - :keyword internal_metric_name: The internal metric name. - :paramtype internal_metric_name: str - """ - super().__init__(**kwargs) - self.name = name - self.display_name = display_name - self.display_description = display_description - self.unit = unit - self.aggregation_type = aggregation_type - self.supported_aggregation_types = supported_aggregation_types - self.supported_time_grain_types = supported_time_grain_types - self.lock_aggregation_type = lock_aggregation_type - self.dimensions = dimensions - self.fill_gap_with_zero = fill_gap_with_zero - self.internal_metric_name = internal_metric_name - - -class NetworkRuleSet(_serialization.Model): - """A set of rules governing the network accessibility of a vault. - - :ivar bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or - 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and - "None". - :vartype bypass: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.NetworkRuleBypassOptions - :ivar default_action: The default action when no rule from ipRules and from virtualNetworkRules - match. This is only used after the bypass property has been evaluated. Known values are: - "Allow" and "Deny". - :vartype default_action: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.NetworkRuleAction - :ivar ip_rules: The list of IP address rules. - :vartype ip_rules: list[~azure.mgmt.keyvault.v2020_04_01_preview.models.IPRule] - :ivar virtual_network_rules: The list of virtual network rules. - :vartype virtual_network_rules: - list[~azure.mgmt.keyvault.v2020_04_01_preview.models.VirtualNetworkRule] - """ - - _attribute_map = { - "bypass": {"key": "bypass", "type": "str"}, - "default_action": {"key": "defaultAction", "type": "str"}, - "ip_rules": {"key": "ipRules", "type": "[IPRule]"}, - "virtual_network_rules": {"key": "virtualNetworkRules", "type": "[VirtualNetworkRule]"}, - } - - def __init__( - self, - *, - bypass: Optional[Union[str, "_models.NetworkRuleBypassOptions"]] = None, - default_action: Optional[Union[str, "_models.NetworkRuleAction"]] = None, - ip_rules: Optional[List["_models.IPRule"]] = None, - virtual_network_rules: Optional[List["_models.VirtualNetworkRule"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or - 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and - "None". - :paramtype bypass: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.NetworkRuleBypassOptions - :keyword default_action: The default action when no rule from ipRules and from - virtualNetworkRules match. This is only used after the bypass property has been evaluated. - Known values are: "Allow" and "Deny". - :paramtype default_action: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.NetworkRuleAction - :keyword ip_rules: The list of IP address rules. - :paramtype ip_rules: list[~azure.mgmt.keyvault.v2020_04_01_preview.models.IPRule] - :keyword virtual_network_rules: The list of virtual network rules. - :paramtype virtual_network_rules: - list[~azure.mgmt.keyvault.v2020_04_01_preview.models.VirtualNetworkRule] - """ - super().__init__(**kwargs) - self.bypass = bypass - self.default_action = default_action - self.ip_rules = ip_rules - self.virtual_network_rules = virtual_network_rules - - -class Operation(_serialization.Model): - """Key Vault REST API operation definition. - - :ivar name: Operation name: {provider}/{resource}/{operation}. - :vartype name: str - :ivar display: Display metadata associated with the operation. - :vartype display: ~azure.mgmt.keyvault.v2020_04_01_preview.models.OperationDisplay - :ivar origin: The origin of operations. - :vartype origin: str - :ivar is_data_action: Property to specify whether the action is a data action. - :vartype is_data_action: bool - :ivar service_specification: One property of operation, include metric specifications. - :vartype service_specification: - ~azure.mgmt.keyvault.v2020_04_01_preview.models.ServiceSpecification - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display": {"key": "display", "type": "OperationDisplay"}, - "origin": {"key": "origin", "type": "str"}, - "is_data_action": {"key": "isDataAction", "type": "bool"}, - "service_specification": {"key": "properties.serviceSpecification", "type": "ServiceSpecification"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display: Optional["_models.OperationDisplay"] = None, - origin: Optional[str] = None, - is_data_action: Optional[bool] = None, - service_specification: Optional["_models.ServiceSpecification"] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Operation name: {provider}/{resource}/{operation}. - :paramtype name: str - :keyword display: Display metadata associated with the operation. - :paramtype display: ~azure.mgmt.keyvault.v2020_04_01_preview.models.OperationDisplay - :keyword origin: The origin of operations. - :paramtype origin: str - :keyword is_data_action: Property to specify whether the action is a data action. - :paramtype is_data_action: bool - :keyword service_specification: One property of operation, include metric specifications. - :paramtype service_specification: - ~azure.mgmt.keyvault.v2020_04_01_preview.models.ServiceSpecification - """ - super().__init__(**kwargs) - self.name = name - self.display = display - self.origin = origin - self.is_data_action = is_data_action - self.service_specification = service_specification - - -class OperationDisplay(_serialization.Model): - """Display metadata associated with the operation. - - :ivar provider: Service provider: Microsoft Key Vault. - :vartype provider: str - :ivar resource: Resource on which the operation is performed etc. - :vartype resource: str - :ivar operation: Type of operation: get, read, delete, etc. - :vartype operation: str - :ivar description: Description of operation. - :vartype description: str - """ - - _attribute_map = { - "provider": {"key": "provider", "type": "str"}, - "resource": {"key": "resource", "type": "str"}, - "operation": {"key": "operation", "type": "str"}, - "description": {"key": "description", "type": "str"}, - } - - def __init__( - self, - *, - provider: Optional[str] = None, - resource: Optional[str] = None, - operation: Optional[str] = None, - description: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword provider: Service provider: Microsoft Key Vault. - :paramtype provider: str - :keyword resource: Resource on which the operation is performed etc. - :paramtype resource: str - :keyword operation: Type of operation: get, read, delete, etc. - :paramtype operation: str - :keyword description: Description of operation. - :paramtype description: str - """ - super().__init__(**kwargs) - self.provider = provider - self.resource = resource - self.operation = operation - self.description = description - - -class OperationListResult(_serialization.Model): - """Result of the request to list Storage operations. It contains a list of operations and a URL - link to get the next set of results. - - :ivar value: List of Storage operations supported by the Storage resource provider. - :vartype value: list[~azure.mgmt.keyvault.v2020_04_01_preview.models.Operation] - :ivar next_link: The URL to get the next set of operations. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Operation]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Operation"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: List of Storage operations supported by the Storage resource provider. - :paramtype value: list[~azure.mgmt.keyvault.v2020_04_01_preview.models.Operation] - :keyword next_link: The URL to get the next set of operations. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class Permissions(_serialization.Model): - """Permissions the identity has for keys, secrets, certificates and storage. - - :ivar keys: Permissions to keys. - :vartype keys: list[str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.KeyPermissions] - :ivar secrets: Permissions to secrets. - :vartype secrets: list[str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretPermissions] - :ivar certificates: Permissions to certificates. - :vartype certificates: list[str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.CertificatePermissions] - :ivar storage: Permissions to storage accounts. - :vartype storage: list[str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.StoragePermissions] - """ - - _attribute_map = { - "keys": {"key": "keys", "type": "[str]"}, - "secrets": {"key": "secrets", "type": "[str]"}, - "certificates": {"key": "certificates", "type": "[str]"}, - "storage": {"key": "storage", "type": "[str]"}, - } - - def __init__( - self, - *, - keys: Optional[List[Union[str, "_models.KeyPermissions"]]] = None, - secrets: Optional[List[Union[str, "_models.SecretPermissions"]]] = None, - certificates: Optional[List[Union[str, "_models.CertificatePermissions"]]] = None, - storage: Optional[List[Union[str, "_models.StoragePermissions"]]] = None, - **kwargs: Any - ) -> None: - """ - :keyword keys: Permissions to keys. - :paramtype keys: list[str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.KeyPermissions] - :keyword secrets: Permissions to secrets. - :paramtype secrets: list[str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretPermissions] - :keyword certificates: Permissions to certificates. - :paramtype certificates: list[str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.CertificatePermissions] - :keyword storage: Permissions to storage accounts. - :paramtype storage: list[str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.StoragePermissions] - """ - super().__init__(**kwargs) - self.keys = keys - self.secrets = secrets - self.certificates = certificates - self.storage = storage - - -class PrivateEndpoint(_serialization.Model): - """Private endpoint object properties. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Full identifier of the private endpoint resource. - :vartype id: str - """ - - _validation = { - "id": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.id = None - - -class PrivateEndpointConnection(Resource): - """Private endpoint connection resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar etag: Modified whenever there is a change in the state of private endpoint connection. - :vartype etag: str - :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpoint - :ivar private_link_service_connection_state: Approval state of the private link connection. - :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateLinkServiceConnectionState - :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values - are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnectionProvisioningState - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - "provisioning_state": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "etag": {"key": "etag", "type": "str"}, - "private_endpoint": {"key": "properties.privateEndpoint", "type": "PrivateEndpoint"}, - "private_link_service_connection_state": { - "key": "properties.privateLinkServiceConnectionState", - "type": "PrivateLinkServiceConnectionState", - }, - "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - etag: Optional[str] = None, - private_endpoint: Optional["_models.PrivateEndpoint"] = None, - private_link_service_connection_state: Optional["_models.PrivateLinkServiceConnectionState"] = None, - **kwargs: Any - ) -> None: - """ - :keyword etag: Modified whenever there is a change in the state of private endpoint connection. - :paramtype etag: str - :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpoint - :keyword private_link_service_connection_state: Approval state of the private link connection. - :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateLinkServiceConnectionState - """ - super().__init__(**kwargs) - self.etag = etag - self.private_endpoint = private_endpoint - self.private_link_service_connection_state = private_link_service_connection_state - self.provisioning_state = None - - -class PrivateEndpointConnectionItem(_serialization.Model): - """Private endpoint connection item. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Id of private endpoint connection. - :vartype id: str - :ivar etag: Modified whenever there is a change in the state of private endpoint connection. - :vartype etag: str - :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpoint - :ivar private_link_service_connection_state: Approval state of the private link connection. - :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateLinkServiceConnectionState - :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values - are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnectionProvisioningState - """ - - _validation = { - "provisioning_state": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "etag": {"key": "etag", "type": "str"}, - "private_endpoint": {"key": "properties.privateEndpoint", "type": "PrivateEndpoint"}, - "private_link_service_connection_state": { - "key": "properties.privateLinkServiceConnectionState", - "type": "PrivateLinkServiceConnectionState", - }, - "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - id: Optional[str] = None, # pylint: disable=redefined-builtin - etag: Optional[str] = None, - private_endpoint: Optional["_models.PrivateEndpoint"] = None, - private_link_service_connection_state: Optional["_models.PrivateLinkServiceConnectionState"] = None, - **kwargs: Any - ) -> None: - """ - :keyword id: Id of private endpoint connection. - :paramtype id: str - :keyword etag: Modified whenever there is a change in the state of private endpoint connection. - :paramtype etag: str - :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpoint - :keyword private_link_service_connection_state: Approval state of the private link connection. - :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateLinkServiceConnectionState - """ - super().__init__(**kwargs) - self.id = id - self.etag = etag - self.private_endpoint = private_endpoint - self.private_link_service_connection_state = private_link_service_connection_state - self.provisioning_state = None - - -class PrivateLinkResource(Resource): - """A private link resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar group_id: Group identifier of private link resource. - :vartype group_id: str - :ivar required_members: Required member names of private link resource. - :vartype required_members: list[str] - :ivar required_zone_names: Required DNS zone names of the the private link resource. - :vartype required_zone_names: list[str] - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - "group_id": {"readonly": True}, - "required_members": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "group_id": {"key": "properties.groupId", "type": "str"}, - "required_members": {"key": "properties.requiredMembers", "type": "[str]"}, - "required_zone_names": {"key": "properties.requiredZoneNames", "type": "[str]"}, - } - - def __init__(self, *, required_zone_names: Optional[List[str]] = None, **kwargs: Any) -> None: - """ - :keyword required_zone_names: Required DNS zone names of the the private link resource. - :paramtype required_zone_names: list[str] - """ - super().__init__(**kwargs) - self.group_id = None - self.required_members = None - self.required_zone_names = required_zone_names - - -class PrivateLinkResourceListResult(_serialization.Model): - """A list of private link resources. - - :ivar value: Array of private link resources. - :vartype value: list[~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateLinkResource] - """ - - _attribute_map = { - "value": {"key": "value", "type": "[PrivateLinkResource]"}, - } - - def __init__(self, *, value: Optional[List["_models.PrivateLinkResource"]] = None, **kwargs: Any) -> None: - """ - :keyword value: Array of private link resources. - :paramtype value: list[~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateLinkResource] - """ - super().__init__(**kwargs) - self.value = value - - -class PrivateLinkServiceConnectionState(_serialization.Model): - """An object that represents the approval state of the private link connection. - - :ivar status: Indicates whether the connection has been approved, rejected or removed by the - key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :vartype status: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointServiceConnectionStatus - :ivar description: The reason for approval or rejection. - :vartype description: str - :ivar actions_required: A message indicating if changes on the service provider require any - updates on the consumer. "None" - :vartype actions_required: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.ActionsRequired - """ - - _attribute_map = { - "status": {"key": "status", "type": "str"}, - "description": {"key": "description", "type": "str"}, - "actions_required": {"key": "actionsRequired", "type": "str"}, - } - - def __init__( - self, - *, - status: Optional[Union[str, "_models.PrivateEndpointServiceConnectionStatus"]] = None, - description: Optional[str] = None, - actions_required: Optional[Union[str, "_models.ActionsRequired"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword status: Indicates whether the connection has been approved, rejected or removed by the - key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :paramtype status: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointServiceConnectionStatus - :keyword description: The reason for approval or rejection. - :paramtype description: str - :keyword actions_required: A message indicating if changes on the service provider require any - updates on the consumer. "None" - :paramtype actions_required: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.ActionsRequired - """ - super().__init__(**kwargs) - self.status = status - self.description = description - self.actions_required = actions_required - - -class ResourceListResult(_serialization.Model): - """List of vault resources. - - :ivar value: The list of vault resources. - :vartype value: list[~azure.mgmt.keyvault.v2020_04_01_preview.models.Resource] - :ivar next_link: The URL to get the next set of vault resources. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Resource]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Resource"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of vault resources. - :paramtype value: list[~azure.mgmt.keyvault.v2020_04_01_preview.models.Resource] - :keyword next_link: The URL to get the next set of vault resources. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class Secret(Resource): - """Resource information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar properties: Properties of the secret. Required. - :vartype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "SecretProperties"}, - } - - def __init__(self, *, properties: "_models.SecretProperties", **kwargs: Any) -> None: - """ - :keyword properties: Properties of the secret. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretProperties - """ - super().__init__(**kwargs) - self.properties = properties - - -class SecretAttributes(Attributes): - """The secret management attributes. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar enabled: Determines whether the object is enabled. - :vartype enabled: bool - :ivar not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :vartype not_before: ~datetime.datetime - :ivar expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :vartype expires: ~datetime.datetime - :ivar created: Creation time in seconds since 1970-01-01T00:00:00Z. - :vartype created: ~datetime.datetime - :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: ~datetime.datetime - """ - - -class SecretCreateOrUpdateParameters(_serialization.Model): - """Parameters for creating or updating a secret. - - All required parameters must be populated in order to send to server. - - :ivar tags: The tags that will be assigned to the secret. - :vartype tags: dict[str, str] - :ivar properties: Properties of the secret. Required. - :vartype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretProperties - """ - - _validation = { - "properties": {"required": True}, - } - - _attribute_map = { - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "SecretProperties"}, - } - - def __init__( - self, *, properties: "_models.SecretProperties", tags: Optional[Dict[str, str]] = None, **kwargs: Any - ) -> None: - """ - :keyword tags: The tags that will be assigned to the secret. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the secret. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretProperties - """ - super().__init__(**kwargs) - self.tags = tags - self.properties = properties - - -class SecretListResult(_serialization.Model): - """List of secrets. - - :ivar value: The list of secrets. - :vartype value: list[~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret] - :ivar next_link: The URL to get the next set of secrets. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Secret]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Secret"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of secrets. - :paramtype value: list[~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret] - :keyword next_link: The URL to get the next set of secrets. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class SecretPatchParameters(_serialization.Model): - """Parameters for patching a secret. - - :ivar tags: The tags that will be assigned to the secret. - :vartype tags: dict[str, str] - :ivar properties: Properties of the secret. - :vartype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretPatchProperties - """ - - _attribute_map = { - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "SecretPatchProperties"}, - } - - def __init__( - self, - *, - tags: Optional[Dict[str, str]] = None, - properties: Optional["_models.SecretPatchProperties"] = None, - **kwargs: Any - ) -> None: - """ - :keyword tags: The tags that will be assigned to the secret. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the secret. - :paramtype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretPatchProperties - """ - super().__init__(**kwargs) - self.tags = tags - self.properties = properties - - -class SecretPatchProperties(_serialization.Model): - """Properties of the secret. - - :ivar value: The value of the secret. - :vartype value: str - :ivar content_type: The content type of the secret. - :vartype content_type: str - :ivar attributes: The attributes of the secret. - :vartype attributes: ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretAttributes - """ - - _attribute_map = { - "value": {"key": "value", "type": "str"}, - "content_type": {"key": "contentType", "type": "str"}, - "attributes": {"key": "attributes", "type": "SecretAttributes"}, - } - - def __init__( - self, - *, - value: Optional[str] = None, - content_type: Optional[str] = None, - attributes: Optional["_models.SecretAttributes"] = None, - **kwargs: Any - ) -> None: - """ - :keyword value: The value of the secret. - :paramtype value: str - :keyword content_type: The content type of the secret. - :paramtype content_type: str - :keyword attributes: The attributes of the secret. - :paramtype attributes: ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretAttributes - """ - super().__init__(**kwargs) - self.value = value - self.content_type = content_type - self.attributes = attributes - - -class SecretProperties(_serialization.Model): - """Properties of the secret. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar value: The value of the secret. NOTE: 'value' will never be returned from the service, as - APIs using this model are is intended for internal use in ARM deployments. Users should use the - data-plane REST service for interaction with vault secrets. - :vartype value: str - :ivar content_type: The content type of the secret. - :vartype content_type: str - :ivar attributes: The attributes of the secret. - :vartype attributes: ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretAttributes - :ivar secret_uri: The URI to retrieve the current version of the secret. - :vartype secret_uri: str - :ivar secret_uri_with_version: The URI to retrieve the specific version of the secret. - :vartype secret_uri_with_version: str - """ - - _validation = { - "secret_uri": {"readonly": True}, - "secret_uri_with_version": {"readonly": True}, - } - - _attribute_map = { - "value": {"key": "value", "type": "str"}, - "content_type": {"key": "contentType", "type": "str"}, - "attributes": {"key": "attributes", "type": "SecretAttributes"}, - "secret_uri": {"key": "secretUri", "type": "str"}, - "secret_uri_with_version": {"key": "secretUriWithVersion", "type": "str"}, - } - - def __init__( - self, - *, - value: Optional[str] = None, - content_type: Optional[str] = None, - attributes: Optional["_models.SecretAttributes"] = None, - **kwargs: Any - ) -> None: - """ - :keyword value: The value of the secret. NOTE: 'value' will never be returned from the service, - as APIs using this model are is intended for internal use in ARM deployments. Users should use - the data-plane REST service for interaction with vault secrets. - :paramtype value: str - :keyword content_type: The content type of the secret. - :paramtype content_type: str - :keyword attributes: The attributes of the secret. - :paramtype attributes: ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretAttributes - """ - super().__init__(**kwargs) - self.value = value - self.content_type = content_type - self.attributes = attributes - self.secret_uri = None - self.secret_uri_with_version = None - - -class ServiceSpecification(_serialization.Model): - """One property of operation, include log specifications. - - :ivar log_specifications: Log specifications of operation. - :vartype log_specifications: - list[~azure.mgmt.keyvault.v2020_04_01_preview.models.LogSpecification] - :ivar metric_specifications: Metric specifications of operation. - :vartype metric_specifications: - list[~azure.mgmt.keyvault.v2020_04_01_preview.models.MetricSpecification] - """ - - _attribute_map = { - "log_specifications": {"key": "logSpecifications", "type": "[LogSpecification]"}, - "metric_specifications": {"key": "metricSpecifications", "type": "[MetricSpecification]"}, - } - - def __init__( - self, - *, - log_specifications: Optional[List["_models.LogSpecification"]] = None, - metric_specifications: Optional[List["_models.MetricSpecification"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword log_specifications: Log specifications of operation. - :paramtype log_specifications: - list[~azure.mgmt.keyvault.v2020_04_01_preview.models.LogSpecification] - :keyword metric_specifications: Metric specifications of operation. - :paramtype metric_specifications: - list[~azure.mgmt.keyvault.v2020_04_01_preview.models.MetricSpecification] - """ - super().__init__(**kwargs) - self.log_specifications = log_specifications - self.metric_specifications = metric_specifications - - -class Sku(_serialization.Model): - """SKU details. - - All required parameters must be populated in order to send to server. - - :ivar family: SKU family name. "A" - :vartype family: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.SkuFamily - :ivar name: SKU name to specify whether the key vault is a standard vault or a premium vault. - Required. Known values are: "standard" and "premium". - :vartype name: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.SkuName - """ - - _validation = { - "family": {"required": True}, - "name": {"required": True}, - } - - _attribute_map = { - "family": {"key": "family", "type": "str"}, - "name": {"key": "name", "type": "str"}, - } - - def __init__( - self, *, family: Union[str, "_models.SkuFamily"] = "A", name: Union[str, "_models.SkuName"], **kwargs: Any - ) -> None: - """ - :keyword family: SKU family name. "A" - :paramtype family: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.SkuFamily - :keyword name: SKU name to specify whether the key vault is a standard vault or a premium - vault. Required. Known values are: "standard" and "premium". - :paramtype name: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.SkuName - """ - super().__init__(**kwargs) - self.family = family - self.name = name - - -class SystemData(_serialization.Model): - """Metadata pertaining to creation and last modification of key vault resource. - - :ivar created_by: The identity that created key vault resource. - :vartype created_by: str - :ivar created_by_type: The type of identity that created key vault resource. Known values are: - "User", "Application", "ManagedIdentity", and "Key". - :vartype created_by_type: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.IdentityType - :ivar created_at: The timestamp of key vault resource creation (UTC). - :vartype created_at: ~datetime.datetime - :ivar last_modified_by: The identity that last modified key vault resource. - :vartype last_modified_by: str - :ivar last_modified_by_type: The type of identity that last modified key vault resource. Known - values are: "User", "Application", "ManagedIdentity", and "Key". - :vartype last_modified_by_type: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.IdentityType - :ivar last_modified_at: The timestamp of key vault resource last modification (UTC). - :vartype last_modified_at: ~datetime.datetime - """ - - _attribute_map = { - "created_by": {"key": "createdBy", "type": "str"}, - "created_by_type": {"key": "createdByType", "type": "str"}, - "created_at": {"key": "createdAt", "type": "iso-8601"}, - "last_modified_by": {"key": "lastModifiedBy", "type": "str"}, - "last_modified_by_type": {"key": "lastModifiedByType", "type": "str"}, - "last_modified_at": {"key": "lastModifiedAt", "type": "iso-8601"}, - } - - def __init__( - self, - *, - created_by: Optional[str] = None, - created_by_type: Optional[Union[str, "_models.IdentityType"]] = None, - created_at: Optional[datetime.datetime] = None, - last_modified_by: Optional[str] = None, - last_modified_by_type: Optional[Union[str, "_models.IdentityType"]] = None, - last_modified_at: Optional[datetime.datetime] = None, - **kwargs: Any - ) -> None: - """ - :keyword created_by: The identity that created key vault resource. - :paramtype created_by: str - :keyword created_by_type: The type of identity that created key vault resource. Known values - are: "User", "Application", "ManagedIdentity", and "Key". - :paramtype created_by_type: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.IdentityType - :keyword created_at: The timestamp of key vault resource creation (UTC). - :paramtype created_at: ~datetime.datetime - :keyword last_modified_by: The identity that last modified key vault resource. - :paramtype last_modified_by: str - :keyword last_modified_by_type: The type of identity that last modified key vault resource. - Known values are: "User", "Application", "ManagedIdentity", and "Key". - :paramtype last_modified_by_type: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.IdentityType - :keyword last_modified_at: The timestamp of key vault resource last modification (UTC). - :paramtype last_modified_at: ~datetime.datetime - """ - super().__init__(**kwargs) - self.created_by = created_by - self.created_by_type = created_by_type - self.created_at = created_at - self.last_modified_by = last_modified_by - self.last_modified_by_type = last_modified_by_type - self.last_modified_at = last_modified_at - - -class Vault(_serialization.Model): - """Resource information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar system_data: System metadata for the key vault. - :vartype system_data: ~azure.mgmt.keyvault.v2020_04_01_preview.models.SystemData - :ivar properties: Properties of the vault. Required. - :vartype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "system_data": {"readonly": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "system_data": {"key": "systemData", "type": "SystemData"}, - "properties": {"key": "properties", "type": "VaultProperties"}, - } - - def __init__( - self, - *, - properties: "_models.VaultProperties", - location: Optional[str] = None, - tags: Optional[Dict[str, str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: Azure location of the key vault resource. - :paramtype location: str - :keyword tags: Tags assigned to the key vault resource. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the vault. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = location - self.tags = tags - self.system_data = None - self.properties = properties - - -class VaultAccessPolicyParameters(_serialization.Model): - """Parameters for updating the access policy in a vault. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar id: The resource id of the access policy. - :vartype id: str - :ivar name: The resource name of the access policy. - :vartype name: str - :ivar type: The resource name of the access policy. - :vartype type: str - :ivar location: The resource type of the access policy. - :vartype location: str - :ivar properties: Properties of the access policy. Required. - :vartype properties: - ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultAccessPolicyProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "properties": {"key": "properties", "type": "VaultAccessPolicyProperties"}, - } - - def __init__(self, *, properties: "_models.VaultAccessPolicyProperties", **kwargs: Any) -> None: - """ - :keyword properties: Properties of the access policy. Required. - :paramtype properties: - ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultAccessPolicyProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = None - self.properties = properties - - -class VaultAccessPolicyProperties(_serialization.Model): - """Properties of the vault access policy. - - All required parameters must be populated in order to send to server. - - :ivar access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. Required. - :vartype access_policies: - list[~azure.mgmt.keyvault.v2020_04_01_preview.models.AccessPolicyEntry] - """ - - _validation = { - "access_policies": {"required": True}, - } - - _attribute_map = { - "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, - } - - def __init__(self, *, access_policies: List["_models.AccessPolicyEntry"], **kwargs: Any) -> None: - """ - :keyword access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. Required. - :paramtype access_policies: - list[~azure.mgmt.keyvault.v2020_04_01_preview.models.AccessPolicyEntry] - """ - super().__init__(**kwargs) - self.access_policies = access_policies - - -class VaultCheckNameAvailabilityParameters(_serialization.Model): - """The parameters used to check the availability of the vault name. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar name: The vault name. Required. - :vartype name: str - :ivar type: The type of resource, Microsoft.KeyVault/vaults. Required. Default value is - "Microsoft.KeyVault/vaults". - :vartype type: str - """ - - _validation = { - "name": {"required": True}, - "type": {"required": True, "constant": True}, - } - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - } - - type = "Microsoft.KeyVault/vaults" - - def __init__(self, *, name: str, **kwargs: Any) -> None: - """ - :keyword name: The vault name. Required. - :paramtype name: str - """ - super().__init__(**kwargs) - self.name = name - - -class VaultCreateOrUpdateParameters(_serialization.Model): - """Parameters for creating or updating a vault. - - All required parameters must be populated in order to send to server. - - :ivar location: The supported Azure location where the key vault should be created. Required. - :vartype location: str - :ivar tags: The tags that will be assigned to the key vault. - :vartype tags: dict[str, str] - :ivar properties: Properties of the vault. Required. - :vartype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultProperties - """ - - _validation = { - "location": {"required": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "VaultProperties"}, - } - - def __init__( - self, - *, - location: str, - properties: "_models.VaultProperties", - tags: Optional[Dict[str, str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the key vault should be created. - Required. - :paramtype location: str - :keyword tags: The tags that will be assigned to the key vault. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the vault. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultProperties - """ - super().__init__(**kwargs) - self.location = location - self.tags = tags - self.properties = properties - - -class VaultListResult(_serialization.Model): - """List of vaults. - - :ivar value: The list of vaults. - :vartype value: list[~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault] - :ivar next_link: The URL to get the next set of vaults. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Vault]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Vault"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of vaults. - :paramtype value: list[~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault] - :keyword next_link: The URL to get the next set of vaults. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class VaultPatchParameters(_serialization.Model): - """Parameters for creating or updating a vault. - - :ivar tags: The tags that will be assigned to the key vault. - :vartype tags: dict[str, str] - :ivar properties: Properties of the vault. - :vartype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultPatchProperties - """ - - _attribute_map = { - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "VaultPatchProperties"}, - } - - def __init__( - self, - *, - tags: Optional[Dict[str, str]] = None, - properties: Optional["_models.VaultPatchProperties"] = None, - **kwargs: Any - ) -> None: - """ - :keyword tags: The tags that will be assigned to the key vault. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the vault. - :paramtype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultPatchProperties - """ - super().__init__(**kwargs) - self.tags = tags - self.properties = properties - - -class VaultPatchProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Properties of the vault. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. - :vartype tenant_id: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Sku - :ivar access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. - :vartype access_policies: - list[~azure.mgmt.keyvault.v2020_04_01_preview.models.AccessPolicyEntry] - :ivar enabled_for_deployment: Property to specify whether Azure Virtual Machines are permitted - to retrieve certificates stored as secrets from the key vault. - :vartype enabled_for_deployment: bool - :ivar enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :vartype enabled_for_disk_encryption: bool - :ivar enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :vartype enabled_for_template_deployment: bool - :ivar enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. Once set to true, it cannot be reverted to false. - :vartype enable_soft_delete: bool - :ivar enable_rbac_authorization: Property that controls how data actions are authorized. When - true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored. When false, - the key vault will use the access policies specified in vault properties, and any policy stored - on Azure Resource Manager will be ignored. If null or not specified, the value of this property - will not change. - :vartype enable_rbac_authorization: bool - :ivar soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and <=90. - :vartype soft_delete_retention_in_days: int - :ivar create_mode: The vault's create mode to indicate whether the vault need to be recovered - or not. Known values are: "recover" and "default". - :vartype create_mode: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.CreateMode - :ivar enable_purge_protection: Property specifying whether protection against purge is enabled - for this vault. Setting this property to true activates protection against purge for this vault - and its content - only the Key Vault service may initiate a hard, irrecoverable deletion. The - setting is effective only if soft delete is also enabled. Enabling this functionality is - irreversible - that is, the property does not accept false as its value. - :vartype enable_purge_protection: bool - :ivar network_acls: A collection of rules governing the accessibility of the vault from - specific network locations. - :vartype network_acls: ~azure.mgmt.keyvault.v2020_04_01_preview.models.NetworkRuleSet - """ - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "sku": {"key": "sku", "type": "Sku"}, - "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, - "enabled_for_deployment": {"key": "enabledForDeployment", "type": "bool"}, - "enabled_for_disk_encryption": {"key": "enabledForDiskEncryption", "type": "bool"}, - "enabled_for_template_deployment": {"key": "enabledForTemplateDeployment", "type": "bool"}, - "enable_soft_delete": {"key": "enableSoftDelete", "type": "bool"}, - "enable_rbac_authorization": {"key": "enableRbacAuthorization", "type": "bool"}, - "soft_delete_retention_in_days": {"key": "softDeleteRetentionInDays", "type": "int"}, - "create_mode": {"key": "createMode", "type": "str"}, - "enable_purge_protection": {"key": "enablePurgeProtection", "type": "bool"}, - "network_acls": {"key": "networkAcls", "type": "NetworkRuleSet"}, - } - - def __init__( - self, - *, - tenant_id: Optional[str] = None, - sku: Optional["_models.Sku"] = None, - access_policies: Optional[List["_models.AccessPolicyEntry"]] = None, - enabled_for_deployment: Optional[bool] = None, - enabled_for_disk_encryption: Optional[bool] = None, - enabled_for_template_deployment: Optional[bool] = None, - enable_soft_delete: Optional[bool] = None, - enable_rbac_authorization: Optional[bool] = None, - soft_delete_retention_in_days: Optional[int] = None, - create_mode: Optional[Union[str, "_models.CreateMode"]] = None, - enable_purge_protection: Optional[bool] = None, - network_acls: Optional["_models.NetworkRuleSet"] = None, - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. - :paramtype tenant_id: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Sku - :keyword access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. - :paramtype access_policies: - list[~azure.mgmt.keyvault.v2020_04_01_preview.models.AccessPolicyEntry] - :keyword enabled_for_deployment: Property to specify whether Azure Virtual Machines are - permitted to retrieve certificates stored as secrets from the key vault. - :paramtype enabled_for_deployment: bool - :keyword enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :paramtype enabled_for_disk_encryption: bool - :keyword enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :paramtype enabled_for_template_deployment: bool - :keyword enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. Once set to true, it cannot be reverted to false. - :paramtype enable_soft_delete: bool - :keyword enable_rbac_authorization: Property that controls how data actions are authorized. - When true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored. When false, - the key vault will use the access policies specified in vault properties, and any policy stored - on Azure Resource Manager will be ignored. If null or not specified, the value of this property - will not change. - :paramtype enable_rbac_authorization: bool - :keyword soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and - <=90. - :paramtype soft_delete_retention_in_days: int - :keyword create_mode: The vault's create mode to indicate whether the vault need to be - recovered or not. Known values are: "recover" and "default". - :paramtype create_mode: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.CreateMode - :keyword enable_purge_protection: Property specifying whether protection against purge is - enabled for this vault. Setting this property to true activates protection against purge for - this vault and its content - only the Key Vault service may initiate a hard, irrecoverable - deletion. The setting is effective only if soft delete is also enabled. Enabling this - functionality is irreversible - that is, the property does not accept false as its value. - :paramtype enable_purge_protection: bool - :keyword network_acls: A collection of rules governing the accessibility of the vault from - specific network locations. - :paramtype network_acls: ~azure.mgmt.keyvault.v2020_04_01_preview.models.NetworkRuleSet - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.sku = sku - self.access_policies = access_policies - self.enabled_for_deployment = enabled_for_deployment - self.enabled_for_disk_encryption = enabled_for_disk_encryption - self.enabled_for_template_deployment = enabled_for_template_deployment - self.enable_soft_delete = enable_soft_delete - self.enable_rbac_authorization = enable_rbac_authorization - self.soft_delete_retention_in_days = soft_delete_retention_in_days - self.create_mode = create_mode - self.enable_purge_protection = enable_purge_protection - self.network_acls = network_acls - - -class VaultProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Properties of the vault. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :vartype tenant_id: str - :ivar sku: SKU details. Required. - :vartype sku: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Sku - :ivar access_policies: An array of 0 to 1024 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. When - ``createMode`` is set to ``recover``\\ , access policies are not required. Otherwise, access - policies are required. - :vartype access_policies: - list[~azure.mgmt.keyvault.v2020_04_01_preview.models.AccessPolicyEntry] - :ivar vault_uri: The URI of the vault for performing operations on keys and secrets. - :vartype vault_uri: str - :ivar enabled_for_deployment: Property to specify whether Azure Virtual Machines are permitted - to retrieve certificates stored as secrets from the key vault. - :vartype enabled_for_deployment: bool - :ivar enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :vartype enabled_for_disk_encryption: bool - :ivar enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :vartype enabled_for_template_deployment: bool - :ivar enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. If it's not set to any value(true or false) when creating new key - vault, it will be set to true by default. Once set to true, it cannot be reverted to false. - :vartype enable_soft_delete: bool - :ivar soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and <=90. - :vartype soft_delete_retention_in_days: int - :ivar enable_rbac_authorization: Property that controls how data actions are authorized. When - true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored. When false, - the key vault will use the access policies specified in vault properties, and any policy stored - on Azure Resource Manager will be ignored. If null or not specified, the vault is created with - the default value of false. Note that management actions are always authorized with RBAC. - :vartype enable_rbac_authorization: bool - :ivar create_mode: The vault's create mode to indicate whether the vault need to be recovered - or not. Known values are: "recover" and "default". - :vartype create_mode: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.CreateMode - :ivar enable_purge_protection: Property specifying whether protection against purge is enabled - for this vault. Setting this property to true activates protection against purge for this vault - and its content - only the Key Vault service may initiate a hard, irrecoverable deletion. The - setting is effective only if soft delete is also enabled. Enabling this functionality is - irreversible - that is, the property does not accept false as its value. - :vartype enable_purge_protection: bool - :ivar network_acls: Rules governing the accessibility of the key vault from specific network - locations. - :vartype network_acls: ~azure.mgmt.keyvault.v2020_04_01_preview.models.NetworkRuleSet - :ivar provisioning_state: Provisioning state of the vault. Known values are: "Succeeded" and - "RegisteringDns". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultProvisioningState - :ivar private_endpoint_connections: List of private endpoint connections associated with the - key vault. - :vartype private_endpoint_connections: - list[~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnectionItem] - """ - - _validation = { - "tenant_id": {"required": True}, - "sku": {"required": True}, - "private_endpoint_connections": {"readonly": True}, - } - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "sku": {"key": "sku", "type": "Sku"}, - "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, - "vault_uri": {"key": "vaultUri", "type": "str"}, - "enabled_for_deployment": {"key": "enabledForDeployment", "type": "bool"}, - "enabled_for_disk_encryption": {"key": "enabledForDiskEncryption", "type": "bool"}, - "enabled_for_template_deployment": {"key": "enabledForTemplateDeployment", "type": "bool"}, - "enable_soft_delete": {"key": "enableSoftDelete", "type": "bool"}, - "soft_delete_retention_in_days": {"key": "softDeleteRetentionInDays", "type": "int"}, - "enable_rbac_authorization": {"key": "enableRbacAuthorization", "type": "bool"}, - "create_mode": {"key": "createMode", "type": "str"}, - "enable_purge_protection": {"key": "enablePurgeProtection", "type": "bool"}, - "network_acls": {"key": "networkAcls", "type": "NetworkRuleSet"}, - "provisioning_state": {"key": "provisioningState", "type": "str"}, - "private_endpoint_connections": { - "key": "privateEndpointConnections", - "type": "[PrivateEndpointConnectionItem]", - }, - } - - def __init__( - self, - *, - tenant_id: str, - sku: "_models.Sku", - access_policies: Optional[List["_models.AccessPolicyEntry"]] = None, - vault_uri: Optional[str] = None, - enabled_for_deployment: Optional[bool] = None, - enabled_for_disk_encryption: Optional[bool] = None, - enabled_for_template_deployment: Optional[bool] = None, - enable_soft_delete: bool = True, - soft_delete_retention_in_days: int = 90, - enable_rbac_authorization: bool = False, - create_mode: Optional[Union[str, "_models.CreateMode"]] = None, - enable_purge_protection: Optional[bool] = None, - network_acls: Optional["_models.NetworkRuleSet"] = None, - provisioning_state: Optional[Union[str, "_models.VaultProvisioningState"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :paramtype tenant_id: str - :keyword sku: SKU details. Required. - :paramtype sku: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Sku - :keyword access_policies: An array of 0 to 1024 identities that have access to the key vault. - All identities in the array must use the same tenant ID as the key vault's tenant ID. When - ``createMode`` is set to ``recover``\\ , access policies are not required. Otherwise, access - policies are required. - :paramtype access_policies: - list[~azure.mgmt.keyvault.v2020_04_01_preview.models.AccessPolicyEntry] - :keyword vault_uri: The URI of the vault for performing operations on keys and secrets. - :paramtype vault_uri: str - :keyword enabled_for_deployment: Property to specify whether Azure Virtual Machines are - permitted to retrieve certificates stored as secrets from the key vault. - :paramtype enabled_for_deployment: bool - :keyword enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :paramtype enabled_for_disk_encryption: bool - :keyword enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :paramtype enabled_for_template_deployment: bool - :keyword enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. If it's not set to any value(true or false) when creating new key - vault, it will be set to true by default. Once set to true, it cannot be reverted to false. - :paramtype enable_soft_delete: bool - :keyword soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and - <=90. - :paramtype soft_delete_retention_in_days: int - :keyword enable_rbac_authorization: Property that controls how data actions are authorized. - When true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored. When false, - the key vault will use the access policies specified in vault properties, and any policy stored - on Azure Resource Manager will be ignored. If null or not specified, the vault is created with - the default value of false. Note that management actions are always authorized with RBAC. - :paramtype enable_rbac_authorization: bool - :keyword create_mode: The vault's create mode to indicate whether the vault need to be - recovered or not. Known values are: "recover" and "default". - :paramtype create_mode: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.CreateMode - :keyword enable_purge_protection: Property specifying whether protection against purge is - enabled for this vault. Setting this property to true activates protection against purge for - this vault and its content - only the Key Vault service may initiate a hard, irrecoverable - deletion. The setting is effective only if soft delete is also enabled. Enabling this - functionality is irreversible - that is, the property does not accept false as its value. - :paramtype enable_purge_protection: bool - :keyword network_acls: Rules governing the accessibility of the key vault from specific network - locations. - :paramtype network_acls: ~azure.mgmt.keyvault.v2020_04_01_preview.models.NetworkRuleSet - :keyword provisioning_state: Provisioning state of the vault. Known values are: "Succeeded" and - "RegisteringDns". - :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultProvisioningState - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.sku = sku - self.access_policies = access_policies - self.vault_uri = vault_uri - self.enabled_for_deployment = enabled_for_deployment - self.enabled_for_disk_encryption = enabled_for_disk_encryption - self.enabled_for_template_deployment = enabled_for_template_deployment - self.enable_soft_delete = enable_soft_delete - self.soft_delete_retention_in_days = soft_delete_retention_in_days - self.enable_rbac_authorization = enable_rbac_authorization - self.create_mode = create_mode - self.enable_purge_protection = enable_purge_protection - self.network_acls = network_acls - self.provisioning_state = provisioning_state - self.private_endpoint_connections = None - - -class VirtualNetworkRule(_serialization.Model): - """A rule governing the accessibility of a vault from a specific virtual network. - - All required parameters must be populated in order to send to server. - - :ivar id: Full resource id of a vnet subnet, such as - '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. - Required. - :vartype id: str - :ivar ignore_missing_vnet_service_endpoint: Property to specify whether NRP will ignore the - check if parent subnet has serviceEndpoints configured. - :vartype ignore_missing_vnet_service_endpoint: bool - """ - - _validation = { - "id": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "ignore_missing_vnet_service_endpoint": {"key": "ignoreMissingVnetServiceEndpoint", "type": "bool"}, - } - - def __init__( - self, - *, - id: str, # pylint: disable=redefined-builtin - ignore_missing_vnet_service_endpoint: Optional[bool] = None, - **kwargs: Any - ) -> None: - """ - :keyword id: Full resource id of a vnet subnet, such as - '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. # pylint: disable=line-too-long - Required. - :paramtype id: str - :keyword ignore_missing_vnet_service_endpoint: Property to specify whether NRP will ignore the - check if parent subnet has serviceEndpoints configured. - :paramtype ignore_missing_vnet_service_endpoint: bool - """ - super().__init__(**kwargs) - self.id = id - self.ignore_missing_vnet_service_endpoint = ignore_missing_vnet_service_endpoint diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/models/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/models/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/models/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/__init__.py deleted file mode 100644 index a86b1e14cf52..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/__init__.py +++ /dev/null @@ -1,31 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._keys_operations import KeysOperations -from ._vaults_operations import VaultsOperations -from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations -from ._private_link_resources_operations import PrivateLinkResourcesOperations -from ._operations import Operations -from ._secrets_operations import SecretsOperations -from ._managed_hsms_operations import ManagedHsmsOperations - -from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "KeysOperations", - "VaultsOperations", - "PrivateEndpointConnectionsOperations", - "PrivateLinkResourcesOperations", - "Operations", - "SecretsOperations", - "ManagedHsmsOperations", -] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_keys_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_keys_operations.py deleted file mode 100644 index 58cd36ac49d8..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_keys_operations.py +++ /dev/null @@ -1,669 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Optional, Type, TypeVar, Union, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_if_not_exist_request( - resource_group_name: str, vault_name: str, key_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "keyName": _SERIALIZER.url("key_name", key_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request( - resource_group_name: str, vault_name: str, key_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "keyName": _SERIALIZER.url("key_name", key_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_version_request( - resource_group_name: str, vault_name: str, key_name: str, key_version: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "keyName": _SERIALIZER.url("key_name", key_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - "keyVersion": _SERIALIZER.url("key_version", key_version, "str", pattern=r"^[a-fA-F0-9]{32}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_versions_request( - resource_group_name: str, vault_name: str, key_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "keyName": _SERIALIZER.url("key_name", key_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class KeysOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2020_04_01_preview.KeyVaultManagementClient`'s - :attr:`keys` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @overload - def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: _models.KeyCreateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.KeyCreateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: Union[_models.KeyCreateParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Is either a - KeyCreateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.KeyCreateParameters or - IO[bytes] - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "KeyCreateParameters") - - _request = build_create_if_not_exist_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def get(self, resource_group_name: str, vault_name: str, key_name: str, **kwargs: Any) -> _models.Key: - """Gets the current version of the specified key from the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key to be retrieved. Required. - :type vault_name: str - :param key_name: The name of the key to be retrieved. Required. - :type key_name: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> Iterable["_models.Key"]: - """Lists the keys in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the keys to be retrieved. Required. - :type vault_name: str - :return: An iterator like instance of either Key or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.Key] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("KeyListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def get_version( - self, resource_group_name: str, vault_name: str, key_name: str, key_version: str, **kwargs: Any - ) -> _models.Key: - """Gets the specified version of the specified key in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key version to be retrieved. - Required. - :type vault_name: str - :param key_name: The name of the key version to be retrieved. Required. - :type key_name: str - :param key_version: The version of the key to be retrieved. Required. - :type key_version: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - _request = build_get_version_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - key_version=key_version, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_versions( - self, resource_group_name: str, vault_name: str, key_name: str, **kwargs: Any - ) -> Iterable["_models.Key"]: - """Lists the versions of the specified key in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key versions to be retrieved. - Required. - :type vault_name: str - :param key_name: The name of the key versions to be retrieved. Required. - :type key_name: str - :return: An iterator like instance of either Key or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.Key] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_versions_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("KeyListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_managed_hsms_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_managed_hsms_operations.py deleted file mode 100644 index 7b11f1b4676e..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_managed_hsms_operations.py +++ /dev/null @@ -1,967 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_or_update_request( - resource_group_name: str, name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_request(resource_group_name: str, name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request(resource_group_name: str, name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request(resource_group_name: str, name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_resource_group_request( - resource_group_name: str, subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_subscription_request( - subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class ManagedHsmsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2020_04_01_preview.KeyVaultManagementClient`'s - :attr:`managed_hsms` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - def _create_or_update_initial( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "ManagedHsm") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def begin_create_or_update( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Is either a ManagedHsm - type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm or IO[bytes] - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._create_or_update_initial( - resource_group_name=resource_group_name, - name=name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.ManagedHsm].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.ManagedHsm]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - def _update_initial( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "ManagedHsm") - - _request = build_update_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @overload - def begin_update( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_update( - self, - resource_group_name: str, - name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def begin_update( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Is either a ManagedHsm type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm or IO[bytes] - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._update_initial( - resource_group_name=resource_group_name, - name=name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.ManagedHsm].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.ManagedHsm]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - def _delete_initial(self, resource_group_name: str, name: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_delete(self, resource_group_name: str, name: str, **kwargs: Any) -> LROPoller[None]: - """Deletes the specified managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: The name of the managed HSM Pool to delete. Required. - :type name: str - :return: An instance of LROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._delete_initial( - resource_group_name=resource_group_name, - name=name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def get(self, resource_group_name: str, name: str, **kwargs: Any) -> Optional[_models.ManagedHsm]: - """Gets the specified managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: The name of the managed HSM Pool. Required. - :type name: str - :return: ManagedHsm or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm or None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[Optional[_models.ManagedHsm]] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> Iterable["_models.ManagedHsm"]: - """The List operation gets information about the managed HSM Pools associated with the - subscription and within the specified resource group. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.ManagedHsm"]: - """The List operation gets information about the managed HSM Pools associated with the - subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_operations.py deleted file mode 100644 index ae2e030544fa..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_operations.py +++ /dev/null @@ -1,154 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Iterable, Optional, Type, TypeVar -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_request(**kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/providers/Microsoft.KeyVault/operations") - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class Operations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2020_04_01_preview.KeyVaultManagementClient`'s - :attr:`operations` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: - """Lists all of the available Key Vault Rest API operations. - - :return: An iterator like instance of either Operation or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.Operation] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("OperationListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_patch.py deleted file mode 100644 index b9604571fae0..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_patch.py +++ /dev/null @@ -1,134 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -import sys -from typing import Any, List, Iterable, Optional, Type -import urllib.parse - -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.rest import HttpRequest -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ._vaults_operations import VaultsOperations as _VaultsOperations, ClsType, build_list_request -from .. import models as _models - -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports - -class VaultsOperations(_VaultsOperations): - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - -__all__: List[str] = ["VaultsOperations"] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_private_endpoint_connections_operations.py deleted file mode 100644 index 469692561b83..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_private_endpoint_connections_operations.py +++ /dev/null @@ -1,517 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterator, Optional, Type, TypeVar, Union, cast, overload - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_get_request( - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_put_request( - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request( - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -class PrivateEndpointConnectionsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2020_04_01_preview.KeyVaultManagementClient`'s - :attr:`private_endpoint_connections` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def get( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Optional[_models.PrivateEndpointConnection]: - """Gets the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: PrivateEndpointConnection or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnection or None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[Optional[_models.PrivateEndpointConnection]] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: _models.PrivateEndpointConnection, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnection - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: Union[_models.PrivateEndpointConnection, IO[bytes]], - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Is either a - PrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnection or - IO[bytes] - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _json = self._serialize.body(properties, "PrivateEndpointConnection") - - _request = build_put_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Azure-AsyncOperation"] = self._deserialize( - "str", response.headers.get("Azure-AsyncOperation") - ) - - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - def _delete_initial( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_delete( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> LROPoller[_models.PrivateEndpointConnection]: - """Deletes the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: An instance of LROPoller that returns either PrivateEndpointConnection or the result - of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._delete_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.PrivateEndpointConnection].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.PrivateEndpointConnection]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_private_link_resources_operations.py deleted file mode 100644 index b2bcf473a0f3..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_private_link_resources_operations.py +++ /dev/null @@ -1,147 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_by_vault_request( - resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class PrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2020_04_01_preview.KeyVaultManagementClient`'s - :attr:`private_link_resources` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list_by_vault( - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> _models.PrivateLinkResourceListResult: - """Gets the private link resources supported for the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :return: PrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateLinkResourceListResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.PrivateLinkResourceListResult] = kwargs.pop("cls", None) - - _request = build_list_by_vault_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_secrets_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_secrets_operations.py deleted file mode 100644 index 0d8f33ba27c5..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_secrets_operations.py +++ /dev/null @@ -1,654 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Optional, Type, TypeVar, Union, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_or_update_request( - resource_group_name: str, vault_name: str, secret_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "secretName": _SERIALIZER.url("secret_name", secret_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_request( - resource_group_name: str, vault_name: str, secret_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "secretName": _SERIALIZER.url("secret_name", secret_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request( - resource_group_name: str, vault_name: str, secret_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "secretName": _SERIALIZER.url("secret_name", secret_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_request( - resource_group_name: str, vault_name: str, subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class SecretsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2020_04_01_preview.KeyVaultManagementClient`'s - :attr:`secrets` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @overload - def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: _models.SecretCreateOrUpdateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Required. - :type parameters: - ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretCreateOrUpdateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: Union[_models.SecretCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Is either a - SecretCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: - ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretCreateOrUpdateParameters or IO[bytes] - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "SecretCreateOrUpdateParameters") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: _models.SecretPatchParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretPatchParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: Union[_models.SecretPatchParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Is either a SecretPatchParameters type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretPatchParameters or - IO[bytes] - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "SecretPatchParameters") - - _request = build_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def get(self, resource_group_name: str, vault_name: str, secret_name: str, **kwargs: Any) -> _models.Secret: - """Gets the specified secret. NOTE: This API is intended for internal use in ARM deployments. - Users should use the data-plane REST service for interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param secret_name: The name of the secret. Required. - :type secret_name: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list( - self, resource_group_name: str, vault_name: str, top: Optional[int] = None, **kwargs: Any - ) -> Iterable["_models.Secret"]: - """The List operation gets information about the secrets in a vault. NOTE: This API is intended - for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Secret or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.SecretListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("SecretListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_vaults_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_vaults_operations.py deleted file mode 100644 index 1123b44bc032..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/operations/_vaults_operations.py +++ /dev/null @@ -1,1614 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Literal, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_or_update_request( - resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_access_policy_request( - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "operationKind": _SERIALIZER.url("operation_kind", operation_kind, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_resource_group_request( - resource_group_name: str, subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_subscription_request( - subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_deleted_request(subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_deleted_request(vault_name: str, location: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "location": _SERIALIZER.url("location", location, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_purge_deleted_request(vault_name: str, location: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge", - ) # pylint: disable=line-too-long - path_format_arguments = { - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "location": _SERIALIZER.url("location", location, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_request(subscription_id: str, *, top: Optional[int] = None, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop("api_version", _params.pop("api-version", "2015-11-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resources") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["$filter"] = _SERIALIZER.query("filter", filter, "str") - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_check_name_availability_request(subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability" - ) - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -class VaultsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2020_04_01_preview.KeyVaultManagementClient`'s - :attr:`vaults` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - def _create_or_update_initial( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 201: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultCreateOrUpdateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> LROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Is either a - VaultCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultCreateOrUpdateParameters - or IO[bytes] - :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._create_or_update_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("Vault", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.Vault].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.Vault]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @overload - def update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultPatchParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultPatchParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultPatchParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Is either a VaultPatchParameters type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultPatchParameters or - IO[bytes] - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultPatchParameters") - - _request = build_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def delete( # pylint: disable=inconsistent-return-statements - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> None: - """Deletes the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault to delete. Required. - :type vault_name: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - @distributed_trace - def get(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> _models.Vault: - """Gets the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: _models.VaultAccessPolicyParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultAccessPolicyParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: Union[_models.VaultAccessPolicyParameters, IO[bytes]], - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or - ~azure.mgmt.keyvault.v2020_04_01_preview.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Is either a - VaultAccessPolicyParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultAccessPolicyParameters - or IO[bytes] - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.VaultAccessPolicyParameters] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") - - _request = build_update_access_policy_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - operation_kind=operation_kind, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> Iterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription and - within the specified resource group. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedVault"]: - """Gets information about the deleted vaults in a subscription. - - :return: An iterator like instance of either DeletedVault or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.DeletedVault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.DeletedVaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("DeletedVaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _models.DeletedVault: - """Gets the deleted Azure key vault. - - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param location: The location of the deleted vault. Required. - :type location: str - :return: DeletedVault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.DeletedVault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[_models.DeletedVault] = kwargs.pop("cls", None) - - _request = build_get_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("DeletedVault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_purge_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_purge_deleted(self, vault_name: str, location: str, **kwargs: Any) -> LROPoller[None]: - """Permanently deletes the specified vault. aka Purges the deleted Azure key vault. - - :param vault_name: The name of the soft-deleted vault. Required. - :type vault_name: str - :param location: The location of the soft-deleted vault. Required. - :type location: str - :return: An instance of LROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._purge_deleted_initial( - vault_name=vault_name, - location=location, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @overload - def check_name_availability( - self, - vault_name: _models.VaultCheckNameAvailabilityParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: - ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultCheckNameAvailabilityParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def check_name_availability( - self, vault_name: IO[bytes], *, content_type: str = "application/json", **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def check_name_availability( - self, vault_name: Union[_models.VaultCheckNameAvailabilityParameters, IO[bytes]], **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Is either a VaultCheckNameAvailabilityParameters type - or a IO[bytes] type. Required. - :type vault_name: - ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultCheckNameAvailabilityParameters or - IO[bytes] - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2020-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.CheckNameAvailabilityResult] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(vault_name, (IOBase, bytes)): - _content = vault_name - else: - _json = self._serialize.body(vault_name, "VaultCheckNameAvailabilityParameters") - - _request = build_check_name_availability_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/py.typed b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/py.typed deleted file mode 100644 index e5aff4f83af8..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/py.typed +++ /dev/null @@ -1 +0,0 @@ -# Marker file for PEP 561. \ No newline at end of file diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/__init__.py deleted file mode 100644 index 6bb4b7c63a45..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/__init__.py +++ /dev/null @@ -1,26 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._key_vault_management_client import KeyVaultManagementClient -from ._version import VERSION - -__version__ = VERSION - -try: - from ._patch import __all__ as _patch_all - from ._patch import * # pylint: disable=unused-wildcard-import -except ImportError: - _patch_all = [] -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "KeyVaultManagementClient", -] -__all__.extend([p for p in _patch_all if p not in __all__]) - -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/_configuration.py deleted file mode 100644 index 008624abb447..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/_configuration.py +++ /dev/null @@ -1,66 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from typing import Any, TYPE_CHECKING - -from azure.core.pipeline import policies -from azure.mgmt.core.policies import ARMChallengeAuthenticationPolicy, ARMHttpLoggingPolicy - -from ._version import VERSION - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials import TokenCredential - - -class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long - """Configuration for KeyVaultManagementClient. - - Note that all parameters used to create this instance are saved as instance - attributes. - - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials.TokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :keyword api_version: Api Version. Default value is "2021-04-01-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str - """ - - def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None: - api_version: str = kwargs.pop("api_version", "2021-04-01-preview") - - if credential is None: - raise ValueError("Parameter 'credential' must not be None.") - if subscription_id is None: - raise ValueError("Parameter 'subscription_id' must not be None.") - - self.credential = credential - self.subscription_id = subscription_id - self.api_version = api_version - self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) - kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) - self.polling_interval = kwargs.get("polling_interval", 30) - self._configure(**kwargs) - - def _configure(self, **kwargs: Any) -> None: - 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.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**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) - self.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs) - self.authentication_policy = kwargs.get("authentication_policy") - if self.credential and not self.authentication_policy: - self.authentication_policy = ARMChallengeAuthenticationPolicy( - self.credential, *self.credential_scopes, **kwargs - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/_key_vault_management_client.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/_key_vault_management_client.py deleted file mode 100644 index e66f9071093b..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/_key_vault_management_client.py +++ /dev/null @@ -1,158 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from copy import deepcopy -from typing import Any, TYPE_CHECKING -from typing_extensions import Self - -from azure.core.pipeline import policies -from azure.core.rest import HttpRequest, HttpResponse -from azure.mgmt.core import ARMPipelineClient -from azure.mgmt.core.policies import ARMAutoResourceProviderRegistrationPolicy - -from . import models as _models -from .._serialization import Deserializer, Serializer -from ._configuration import KeyVaultManagementClientConfiguration -from .operations import ( - MHSMPrivateEndpointConnectionsOperations, - MHSMPrivateLinkResourcesOperations, - ManagedHsmsOperations, - Operations, - PrivateEndpointConnectionsOperations, - PrivateLinkResourcesOperations, - VaultsOperations, -) - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials import TokenCredential - - -class KeyVaultManagementClient: # pylint: disable=client-accepts-api-version-keyword,too-many-instance-attributes - """The Azure management API provides a RESTful set of web services that interact with Azure Key - Vault. - - :ivar vaults: VaultsOperations operations - :vartype vaults: azure.mgmt.keyvault.v2021_04_01_preview.operations.VaultsOperations - :ivar private_endpoint_connections: PrivateEndpointConnectionsOperations operations - :vartype private_endpoint_connections: - azure.mgmt.keyvault.v2021_04_01_preview.operations.PrivateEndpointConnectionsOperations - :ivar private_link_resources: PrivateLinkResourcesOperations operations - :vartype private_link_resources: - azure.mgmt.keyvault.v2021_04_01_preview.operations.PrivateLinkResourcesOperations - :ivar managed_hsms: ManagedHsmsOperations operations - :vartype managed_hsms: azure.mgmt.keyvault.v2021_04_01_preview.operations.ManagedHsmsOperations - :ivar mhsm_private_endpoint_connections: MHSMPrivateEndpointConnectionsOperations operations - :vartype mhsm_private_endpoint_connections: - azure.mgmt.keyvault.v2021_04_01_preview.operations.MHSMPrivateEndpointConnectionsOperations - :ivar mhsm_private_link_resources: MHSMPrivateLinkResourcesOperations operations - :vartype mhsm_private_link_resources: - azure.mgmt.keyvault.v2021_04_01_preview.operations.MHSMPrivateLinkResourcesOperations - :ivar operations: Operations operations - :vartype operations: azure.mgmt.keyvault.v2021_04_01_preview.operations.Operations - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials.TokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :param base_url: Service URL. Default value is "https://management.azure.com". - :type base_url: str - :keyword api_version: Api Version. Default value is "2021-04-01-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. - """ - - def __init__( - self, - credential: "TokenCredential", - subscription_id: str, - base_url: str = "https://management.azure.com", - **kwargs: Any - ) -> None: - self._config = KeyVaultManagementClientConfiguration( - credential=credential, subscription_id=subscription_id, **kwargs - ) - _policies = kwargs.pop("policies", None) - if _policies is None: - _policies = [ - policies.RequestIdPolicy(**kwargs), - self._config.headers_policy, - self._config.user_agent_policy, - self._config.proxy_policy, - policies.ContentDecodePolicy(**kwargs), - ARMAutoResourceProviderRegistrationPolicy(), - self._config.redirect_policy, - self._config.retry_policy, - self._config.authentication_policy, - self._config.custom_hook_policy, - self._config.logging_policy, - policies.DistributedTracingPolicy(**kwargs), - policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, - self._config.http_logging_policy, - ] - self._client: ARMPipelineClient = ARMPipelineClient(base_url=base_url, policies=_policies, **kwargs) - - client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} - self._serialize = Serializer(client_models) - self._deserialize = Deserializer(client_models) - self._serialize.client_side_validation = False - self.vaults = VaultsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-04-01-preview" - ) - self.private_endpoint_connections = PrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-04-01-preview" - ) - self.private_link_resources = PrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-04-01-preview" - ) - self.managed_hsms = ManagedHsmsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-04-01-preview" - ) - self.mhsm_private_endpoint_connections = MHSMPrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-04-01-preview" - ) - self.mhsm_private_link_resources = MHSMPrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-04-01-preview" - ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize, "2021-04-01-preview" - ) - - def _send_request(self, request: HttpRequest, *, stream: bool = False, **kwargs: Any) -> HttpResponse: - """Runs the network request through the client's chained policies. - - >>> from azure.core.rest import HttpRequest - >>> request = HttpRequest("GET", "https://www.example.org/") - - >>> response = client._send_request(request) - - - For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request - - :param request: The network request you want to make. Required. - :type request: ~azure.core.rest.HttpRequest - :keyword bool stream: Whether the response payload will be streamed. Defaults to False. - :return: The response of your network call. Does not do error handling on your response. - :rtype: ~azure.core.rest.HttpResponse - """ - - request_copy = deepcopy(request) - request_copy.url = self._client.format_url(request_copy.url) - return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore - - def close(self) -> None: - self._client.close() - - def __enter__(self) -> Self: - self._client.__enter__() - return self - - def __exit__(self, *exc_details: Any) -> None: - self._client.__exit__(*exc_details) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/_metadata.json b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/_metadata.json deleted file mode 100644 index 067b2dd700bb..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/_metadata.json +++ /dev/null @@ -1,116 +0,0 @@ -{ - "chosen_version": "2021-04-01-preview", - "total_api_version_list": ["2021-04-01-preview"], - "client": { - "name": "KeyVaultManagementClient", - "filename": "_key_vault_management_client", - "description": "The Azure management API provides a RESTful set of web services that interact with Azure Key Vault.", - "host_value": "\"https://management.azure.com\"", - "parameterized_host_template": null, - "azure_arm": true, - "has_public_lro_operations": true, - "client_side_validation": false, - "sync_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"sdkcore\": {\"azure.mgmt.core\": [\"ARMPipelineClient\"], \"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"ARMAutoResourceProviderRegistrationPolicy\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \".._serialization\": [\"Deserializer\", \"Serializer\"]}, \"stdlib\": {\"typing_extensions\": [\"Self\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}}", - "async_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"sdkcore\": {\"azure.mgmt.core\": [\"AsyncARMPipelineClient\"], \"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"AsyncARMAutoResourceProviderRegistrationPolicy\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \"..._serialization\": [\"Deserializer\", \"Serializer\"]}, \"stdlib\": {\"typing_extensions\": [\"Self\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"]}}}" - }, - "global_parameters": { - "sync": { - "credential": { - "signature": "credential: \"TokenCredential\",", - "description": "Credential needed for the client to connect to Azure. Required.", - "docstring_type": "~azure.core.credentials.TokenCredential", - "required": true, - "method_location": "positional" - }, - "subscription_id": { - "signature": "subscription_id: str,", - "description": "Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. Required.", - "docstring_type": "str", - "required": true, - "method_location": "positional" - } - }, - "async": { - "credential": { - "signature": "credential: \"AsyncTokenCredential\",", - "description": "Credential needed for the client to connect to Azure. Required.", - "docstring_type": "~azure.core.credentials_async.AsyncTokenCredential", - "required": true - }, - "subscription_id": { - "signature": "subscription_id: str,", - "description": "Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. Required.", - "docstring_type": "str", - "required": true - } - }, - "constant": { - }, - "call": "credential, subscription_id", - "service_client_specific": { - "sync": { - "api_version": { - "signature": "api_version: Optional[str]=None,", - "description": "API version to use if no profile is provided, or if missing in profile.", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "base_url": { - "signature": "base_url: str = \"https://management.azure.com\",", - "description": "Service URL", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "profile": { - "signature": "profile: KnownProfiles=KnownProfiles.default,", - "description": "A profile definition, from KnownProfiles to dict.", - "docstring_type": "azure.profiles.KnownProfiles", - "required": false, - "method_location": "positional" - } - }, - "async": { - "api_version": { - "signature": "api_version: Optional[str] = None,", - "description": "API version to use if no profile is provided, or if missing in profile.", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "base_url": { - "signature": "base_url: str = \"https://management.azure.com\",", - "description": "Service URL", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "profile": { - "signature": "profile: KnownProfiles = KnownProfiles.default,", - "description": "A profile definition, from KnownProfiles to dict.", - "docstring_type": "azure.profiles.KnownProfiles", - "required": false, - "method_location": "positional" - } - } - } - }, - "config": { - "credential": true, - "credential_scopes": ["https://management.azure.com/.default"], - "credential_call_sync": "ARMChallengeAuthenticationPolicy(self.credential, *self.credential_scopes, **kwargs)", - "credential_call_async": "AsyncARMChallengeAuthenticationPolicy(self.credential, *self.credential_scopes, **kwargs)", - "sync_imports": "{\"regular\": {\"sdkcore\": {\"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"ARMChallengeAuthenticationPolicy\", \"ARMHttpLoggingPolicy\"]}, \"local\": {\"._version\": [\"VERSION\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}}", - "async_imports": "{\"regular\": {\"sdkcore\": {\"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"ARMHttpLoggingPolicy\", \"AsyncARMChallengeAuthenticationPolicy\"]}, \"local\": {\".._version\": [\"VERSION\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"]}}}" - }, - "operation_groups": { - "vaults": "VaultsOperations", - "private_endpoint_connections": "PrivateEndpointConnectionsOperations", - "private_link_resources": "PrivateLinkResourcesOperations", - "managed_hsms": "ManagedHsmsOperations", - "mhsm_private_endpoint_connections": "MHSMPrivateEndpointConnectionsOperations", - "mhsm_private_link_resources": "MHSMPrivateLinkResourcesOperations", - "operations": "Operations" - } -} diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/_version.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/_version.py deleted file mode 100644 index 3b99a1418535..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/_version.py +++ /dev/null @@ -1,9 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -VERSION = "10.3.1" diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/__init__.py deleted file mode 100644 index 6ba0c5a05353..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/__init__.py +++ /dev/null @@ -1,23 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._key_vault_management_client import KeyVaultManagementClient - -try: - from ._patch import __all__ as _patch_all - from ._patch import * # pylint: disable=unused-wildcard-import -except ImportError: - _patch_all = [] -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "KeyVaultManagementClient", -] -__all__.extend([p for p in _patch_all if p not in __all__]) - -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/_configuration.py deleted file mode 100644 index 76f3883d5487..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/_configuration.py +++ /dev/null @@ -1,66 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from typing import Any, TYPE_CHECKING - -from azure.core.pipeline import policies -from azure.mgmt.core.policies import ARMHttpLoggingPolicy, AsyncARMChallengeAuthenticationPolicy - -from .._version import VERSION - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials_async import AsyncTokenCredential - - -class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long - """Configuration for KeyVaultManagementClient. - - Note that all parameters used to create this instance are saved as instance - attributes. - - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials_async.AsyncTokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :keyword api_version: Api Version. Default value is "2021-04-01-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str - """ - - def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None: - api_version: str = kwargs.pop("api_version", "2021-04-01-preview") - - if credential is None: - raise ValueError("Parameter 'credential' must not be None.") - if subscription_id is None: - raise ValueError("Parameter 'subscription_id' must not be None.") - - self.credential = credential - self.subscription_id = subscription_id - self.api_version = api_version - self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) - kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) - self.polling_interval = kwargs.get("polling_interval", 30) - self._configure(**kwargs) - - def _configure(self, **kwargs: Any) -> None: - 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.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**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) - self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) - self.authentication_policy = kwargs.get("authentication_policy") - if self.credential and not self.authentication_policy: - self.authentication_policy = AsyncARMChallengeAuthenticationPolicy( - self.credential, *self.credential_scopes, **kwargs - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/_key_vault_management_client.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/_key_vault_management_client.py deleted file mode 100644 index 98a9eebfb200..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/_key_vault_management_client.py +++ /dev/null @@ -1,161 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from copy import deepcopy -from typing import Any, Awaitable, TYPE_CHECKING -from typing_extensions import Self - -from azure.core.pipeline import policies -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.mgmt.core import AsyncARMPipelineClient -from azure.mgmt.core.policies import AsyncARMAutoResourceProviderRegistrationPolicy - -from .. import models as _models -from ..._serialization import Deserializer, Serializer -from ._configuration import KeyVaultManagementClientConfiguration -from .operations import ( - MHSMPrivateEndpointConnectionsOperations, - MHSMPrivateLinkResourcesOperations, - ManagedHsmsOperations, - Operations, - PrivateEndpointConnectionsOperations, - PrivateLinkResourcesOperations, - VaultsOperations, -) - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials_async import AsyncTokenCredential - - -class KeyVaultManagementClient: # pylint: disable=client-accepts-api-version-keyword,too-many-instance-attributes - """The Azure management API provides a RESTful set of web services that interact with Azure Key - Vault. - - :ivar vaults: VaultsOperations operations - :vartype vaults: azure.mgmt.keyvault.v2021_04_01_preview.aio.operations.VaultsOperations - :ivar private_endpoint_connections: PrivateEndpointConnectionsOperations operations - :vartype private_endpoint_connections: - azure.mgmt.keyvault.v2021_04_01_preview.aio.operations.PrivateEndpointConnectionsOperations - :ivar private_link_resources: PrivateLinkResourcesOperations operations - :vartype private_link_resources: - azure.mgmt.keyvault.v2021_04_01_preview.aio.operations.PrivateLinkResourcesOperations - :ivar managed_hsms: ManagedHsmsOperations operations - :vartype managed_hsms: - azure.mgmt.keyvault.v2021_04_01_preview.aio.operations.ManagedHsmsOperations - :ivar mhsm_private_endpoint_connections: MHSMPrivateEndpointConnectionsOperations operations - :vartype mhsm_private_endpoint_connections: - azure.mgmt.keyvault.v2021_04_01_preview.aio.operations.MHSMPrivateEndpointConnectionsOperations - :ivar mhsm_private_link_resources: MHSMPrivateLinkResourcesOperations operations - :vartype mhsm_private_link_resources: - azure.mgmt.keyvault.v2021_04_01_preview.aio.operations.MHSMPrivateLinkResourcesOperations - :ivar operations: Operations operations - :vartype operations: azure.mgmt.keyvault.v2021_04_01_preview.aio.operations.Operations - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials_async.AsyncTokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :param base_url: Service URL. Default value is "https://management.azure.com". - :type base_url: str - :keyword api_version: Api Version. Default value is "2021-04-01-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. - """ - - def __init__( - self, - credential: "AsyncTokenCredential", - subscription_id: str, - base_url: str = "https://management.azure.com", - **kwargs: Any - ) -> None: - self._config = KeyVaultManagementClientConfiguration( - credential=credential, subscription_id=subscription_id, **kwargs - ) - _policies = kwargs.pop("policies", None) - if _policies is None: - _policies = [ - policies.RequestIdPolicy(**kwargs), - self._config.headers_policy, - self._config.user_agent_policy, - self._config.proxy_policy, - policies.ContentDecodePolicy(**kwargs), - AsyncARMAutoResourceProviderRegistrationPolicy(), - self._config.redirect_policy, - self._config.retry_policy, - self._config.authentication_policy, - self._config.custom_hook_policy, - self._config.logging_policy, - policies.DistributedTracingPolicy(**kwargs), - policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, - self._config.http_logging_policy, - ] - self._client: AsyncARMPipelineClient = AsyncARMPipelineClient(base_url=base_url, policies=_policies, **kwargs) - - client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} - self._serialize = Serializer(client_models) - self._deserialize = Deserializer(client_models) - self._serialize.client_side_validation = False - self.vaults = VaultsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-04-01-preview" - ) - self.private_endpoint_connections = PrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-04-01-preview" - ) - self.private_link_resources = PrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-04-01-preview" - ) - self.managed_hsms = ManagedHsmsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-04-01-preview" - ) - self.mhsm_private_endpoint_connections = MHSMPrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-04-01-preview" - ) - self.mhsm_private_link_resources = MHSMPrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-04-01-preview" - ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize, "2021-04-01-preview" - ) - - def _send_request( - self, request: HttpRequest, *, stream: bool = False, **kwargs: Any - ) -> Awaitable[AsyncHttpResponse]: - """Runs the network request through the client's chained policies. - - >>> from azure.core.rest import HttpRequest - >>> request = HttpRequest("GET", "https://www.example.org/") - - >>> response = await client._send_request(request) - - - For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request - - :param request: The network request you want to make. Required. - :type request: ~azure.core.rest.HttpRequest - :keyword bool stream: Whether the response payload will be streamed. Defaults to False. - :return: The response of your network call. Does not do error handling on your response. - :rtype: ~azure.core.rest.AsyncHttpResponse - """ - - request_copy = deepcopy(request) - request_copy.url = self._client.format_url(request_copy.url) - return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore - - async def close(self) -> None: - await self._client.close() - - async def __aenter__(self) -> Self: - await self._client.__aenter__() - return self - - async def __aexit__(self, *exc_details: Any) -> None: - await self._client.__aexit__(*exc_details) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/__init__.py deleted file mode 100644 index 1415b7f904e4..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/__init__.py +++ /dev/null @@ -1,31 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._vaults_operations import VaultsOperations -from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations -from ._private_link_resources_operations import PrivateLinkResourcesOperations -from ._managed_hsms_operations import ManagedHsmsOperations -from ._mhsm_private_endpoint_connections_operations import MHSMPrivateEndpointConnectionsOperations -from ._mhsm_private_link_resources_operations import MHSMPrivateLinkResourcesOperations -from ._operations import Operations - -from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "VaultsOperations", - "PrivateEndpointConnectionsOperations", - "PrivateLinkResourcesOperations", - "ManagedHsmsOperations", - "MHSMPrivateEndpointConnectionsOperations", - "MHSMPrivateLinkResourcesOperations", - "Operations", -] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_managed_hsms_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_managed_hsms_operations.py deleted file mode 100644 index 5f64c7827057..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_managed_hsms_operations.py +++ /dev/null @@ -1,1040 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._managed_hsms_operations import ( - build_create_or_update_request, - build_delete_request, - build_get_deleted_request, - build_get_request, - build_list_by_resource_group_request, - build_list_by_subscription_request, - build_list_deleted_request, - build_purge_deleted_request, - build_update_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class ManagedHsmsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_04_01_preview.aio.KeyVaultManagementClient`'s - :attr:`managed_hsms` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - async def _create_or_update_initial( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "ManagedHsm") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def begin_create_or_update( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Is either a ManagedHsm - type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm or IO[bytes] - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._create_or_update_initial( - resource_group_name=resource_group_name, - name=name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.ManagedHsm].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.ManagedHsm]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - async def _update_initial( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "ManagedHsm") - - _request = build_update_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @overload - async def begin_update( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_update( - self, - resource_group_name: str, - name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def begin_update( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Is either a ManagedHsm type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm or IO[bytes] - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._update_initial( - resource_group_name=resource_group_name, - name=name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.ManagedHsm].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.ManagedHsm]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - async def _delete_initial(self, resource_group_name: str, name: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_delete(self, resource_group_name: str, name: str, **kwargs: Any) -> AsyncLROPoller[None]: - """Deletes the specified managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: The name of the managed HSM Pool to delete. Required. - :type name: str - :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._delete_initial( - resource_group_name=resource_group_name, - name=name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace_async - async def get(self, resource_group_name: str, name: str, **kwargs: Any) -> Optional[_models.ManagedHsm]: - """Gets the specified managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: The name of the managed HSM Pool. Required. - :type name: str - :return: ManagedHsm or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm or None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[Optional[_models.ManagedHsm]] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable["_models.ManagedHsm"]: - """The List operation gets information about the managed HSM Pools associated with the - subscription and within the specified resource group. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.ManagedHsm"]: - """The List operation gets information about the managed HSM Pools associated with the - subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedManagedHsm"]: - """The List operation gets information about the deleted managed HSMs associated with the - subscription. - - :return: An iterator like instance of either DeletedManagedHsm or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.DeletedManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.DeletedManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("DeletedManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace_async - async def get_deleted(self, name: str, location: str, **kwargs: Any) -> _models.DeletedManagedHsm: - """Gets the specified deleted managed HSM. - - :param name: The name of the deleted managed HSM. Required. - :type name: str - :param location: The location of the deleted managed HSM. Required. - :type location: str - :return: DeletedManagedHsm or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.DeletedManagedHsm - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.DeletedManagedHsm] = kwargs.pop("cls", None) - - _request = build_get_deleted_request( - name=name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = self._deserialize("DeletedManagedHsm", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - async def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_purge_deleted_request( - name=name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_purge_deleted(self, name: str, location: str, **kwargs: Any) -> AsyncLROPoller[None]: - """Permanently deletes the specified managed HSM. - - :param name: The name of the soft-deleted managed HSM. Required. - :type name: str - :param location: The location of the soft-deleted managed HSM. Required. - :type location: str - :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._purge_deleted_initial( - name=name, - location=location, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_mhsm_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_mhsm_private_endpoint_connections_operations.py deleted file mode 100644 index 2c6ad04f6cce..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_mhsm_private_endpoint_connections_operations.py +++ /dev/null @@ -1,498 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._mhsm_private_endpoint_connections_operations import ( - build_delete_request, - build_get_request, - build_list_by_resource_request, - build_put_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class MHSMPrivateEndpointConnectionsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_04_01_preview.aio.KeyVaultManagementClient`'s - :attr:`mhsm_private_endpoint_connections` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list_by_resource( - self, resource_group_name: str, name: str, **kwargs: Any - ) -> AsyncIterable["_models.MHSMPrivateEndpointConnection"]: - """The List operation gets information about the private endpoint connections associated with the - managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :return: An iterator like instance of either MHSMPrivateEndpointConnection or the result of - cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("MHSMPrivateEndpointConnectionsListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace_async - async def get( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Gets the specified private endpoint connection associated with the managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: _models.MHSMPrivateEndpointConnection, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: Union[_models.MHSMPrivateEndpointConnection, IO[bytes]], - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Is either a - MHSMPrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection - or IO[bytes] - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _json = self._serialize.body(properties, "MHSMPrivateEndpointConnection") - - _request = build_put_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Azure-AsyncOperation"] = self._deserialize( - "str", response.headers.get("Azure-AsyncOperation") - ) - - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - async def _delete_initial( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_delete( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> AsyncLROPoller[_models.MHSMPrivateEndpointConnection]: - """Deletes the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :return: An instance of AsyncLROPoller that returns either MHSMPrivateEndpointConnection or the - result of cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._delete_initial( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.MHSMPrivateEndpointConnection].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.MHSMPrivateEndpointConnection]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_mhsm_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_mhsm_private_link_resources_operations.py deleted file mode 100644 index 5d994dbd02c7..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_mhsm_private_link_resources_operations.py +++ /dev/null @@ -1,114 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._mhsm_private_link_resources_operations import build_list_by_mhsm_resource_request - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class MHSMPrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_04_01_preview.aio.KeyVaultManagementClient`'s - :attr:`mhsm_private_link_resources` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace_async - async def list_by_mhsm_resource( - self, resource_group_name: str, name: str, **kwargs: Any - ) -> _models.MHSMPrivateLinkResourceListResult: - """Gets the private link resources supported for the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :return: MHSMPrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateLinkResourceListResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.MHSMPrivateLinkResourceListResult] = kwargs.pop("cls", None) - - _request = build_list_by_mhsm_resource_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("MHSMPrivateLinkResourceListResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_operations.py deleted file mode 100644 index 68f7925ed707..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_operations.py +++ /dev/null @@ -1,133 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, AsyncIterable, Callable, Dict, Optional, Type, TypeVar -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._operations import build_list_request - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class Operations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_04_01_preview.aio.KeyVaultManagementClient`'s - :attr:`operations` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: - """Lists all of the available Key Vault Rest API operations. - - :return: An iterator like instance of either Operation or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.Operation] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("OperationListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_patch.py deleted file mode 100644 index 9b4f32f151b7..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_patch.py +++ /dev/null @@ -1,136 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -import sys -from typing import AsyncIterable, Any, Optional, List, Type -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ._vaults_operations import VaultsOperations as _VaultsOperations, ClsType -from ...operations._vaults_operations import build_list_request - -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports - -class VaultsOperations(_VaultsOperations): - - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - -__all__: List[str] = ["VaultsOperations"] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_private_endpoint_connections_operations.py deleted file mode 100644 index 1af19f3c4b5e..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_private_endpoint_connections_operations.py +++ /dev/null @@ -1,492 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._private_endpoint_connections_operations import ( - build_delete_request, - build_get_request, - build_list_by_resource_request, - build_put_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class PrivateEndpointConnectionsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_04_01_preview.aio.KeyVaultManagementClient`'s - :attr:`private_endpoint_connections` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace_async - async def get( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Optional[_models.PrivateEndpointConnection]: - """Gets the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: PrivateEndpointConnection or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection or None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[Optional[_models.PrivateEndpointConnection]] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: _models.PrivateEndpointConnection, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: Union[_models.PrivateEndpointConnection, IO[bytes]], - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Is either a - PrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection or - IO[bytes] - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _json = self._serialize.body(properties, "PrivateEndpointConnection") - - _request = build_put_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Azure-AsyncOperation"] = self._deserialize( - "str", response.headers.get("Azure-AsyncOperation") - ) - - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - async def _delete_initial( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_delete( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> AsyncLROPoller[_models.PrivateEndpointConnection]: - """Deletes the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: An instance of AsyncLROPoller that returns either PrivateEndpointConnection or the - result of cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._delete_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.PrivateEndpointConnection].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.PrivateEndpointConnection]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @distributed_trace - def list_by_resource( - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> AsyncIterable["_models.PrivateEndpointConnection"]: - """The List operation gets information about the private endpoint connections associated with the - vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :return: An iterator like instance of either PrivateEndpointConnection or the result of - cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.PrivateEndpointConnectionListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("PrivateEndpointConnectionListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_private_link_resources_operations.py deleted file mode 100644 index 68e899255350..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_private_link_resources_operations.py +++ /dev/null @@ -1,113 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._private_link_resources_operations import build_list_by_vault_request - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class PrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_04_01_preview.aio.KeyVaultManagementClient`'s - :attr:`private_link_resources` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace_async - async def list_by_vault( - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> _models.PrivateLinkResourceListResult: - """Gets the private link resources supported for the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :return: PrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateLinkResourceListResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.PrivateLinkResourceListResult] = kwargs.pop("cls", None) - - _request = build_list_by_vault_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_vaults_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_vaults_operations.py deleted file mode 100644 index edf1cabfc73b..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/aio/operations/_vaults_operations.py +++ /dev/null @@ -1,1281 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import ( - Any, - AsyncIterable, - AsyncIterator, - Callable, - Dict, - IO, - Literal, - Optional, - Type, - TypeVar, - Union, - cast, - overload, -) -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._vaults_operations import ( - build_check_name_availability_request, - build_create_or_update_request, - build_delete_request, - build_get_deleted_request, - build_get_request, - build_list_by_resource_group_request, - build_list_by_subscription_request, - build_list_deleted_request, - build_list_request, - build_purge_deleted_request, - build_update_access_policy_request, - build_update_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class VaultsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_04_01_preview.aio.KeyVaultManagementClient`'s - :attr:`vaults` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - async def _create_or_update_initial( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 201: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultCreateOrUpdateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> AsyncLROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Is either a - VaultCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultCreateOrUpdateParameters - or IO[bytes] - :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._create_or_update_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("Vault", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.Vault].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.Vault]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @overload - async def update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultPatchParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultPatchParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultPatchParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Is either a VaultPatchParameters type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultPatchParameters or - IO[bytes] - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultPatchParameters") - - _request = build_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def delete( # pylint: disable=inconsistent-return-statements - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> None: - """Deletes the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault to delete. Required. - :type vault_name: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - @distributed_trace_async - async def get(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> _models.Vault: - """Gets the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: _models.VaultAccessPolicyParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultAccessPolicyParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: Union[_models.VaultAccessPolicyParameters, IO[bytes]], - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Is either a - VaultAccessPolicyParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultAccessPolicyParameters - or IO[bytes] - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.VaultAccessPolicyParameters] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") - - _request = build_update_access_policy_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - operation_kind=operation_kind, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription and - within the specified resource group. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedVault"]: - """Gets information about the deleted vaults in a subscription. - - :return: An iterator like instance of either DeletedVault or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.DeletedVault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.DeletedVaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("DeletedVaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace_async - async def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _models.DeletedVault: - """Gets the deleted Azure key vault. - - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param location: The location of the deleted vault. Required. - :type location: str - :return: DeletedVault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.DeletedVault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.DeletedVault] = kwargs.pop("cls", None) - - _request = build_get_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("DeletedVault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - async def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_purge_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_purge_deleted(self, vault_name: str, location: str, **kwargs: Any) -> AsyncLROPoller[None]: - """Permanently deletes the specified vault. aka Purges the deleted Azure key vault. - - :param vault_name: The name of the soft-deleted vault. Required. - :type vault_name: str - :param location: The location of the soft-deleted vault. Required. - :type location: str - :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._purge_deleted_initial( - vault_name=vault_name, - location=location, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @overload - async def check_name_availability( - self, - vault_name: _models.VaultCheckNameAvailabilityParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: - ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultCheckNameAvailabilityParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def check_name_availability( - self, vault_name: IO[bytes], *, content_type: str = "application/json", **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def check_name_availability( - self, vault_name: Union[_models.VaultCheckNameAvailabilityParameters, IO[bytes]], **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Is either a VaultCheckNameAvailabilityParameters type - or a IO[bytes] type. Required. - :type vault_name: - ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultCheckNameAvailabilityParameters or - IO[bytes] - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.CheckNameAvailabilityResult] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(vault_name, (IOBase, bytes)): - _content = vault_name - else: - _json = self._serialize.body(vault_name, "VaultCheckNameAvailabilityParameters") - - _request = build_check_name_availability_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/models/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/models/__init__.py deleted file mode 100644 index ca7b9e0635de..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/models/__init__.py +++ /dev/null @@ -1,171 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._models_py3 import AccessPolicyEntry -from ._models_py3 import CheckNameAvailabilityResult -from ._models_py3 import CloudErrorBody -from ._models_py3 import DeletedManagedHsm -from ._models_py3 import DeletedManagedHsmListResult -from ._models_py3 import DeletedManagedHsmProperties -from ._models_py3 import DeletedVault -from ._models_py3 import DeletedVaultListResult -from ._models_py3 import DeletedVaultProperties -from ._models_py3 import DimensionProperties -from ._models_py3 import Error -from ._models_py3 import IPRule -from ._models_py3 import LogSpecification -from ._models_py3 import MHSMIPRule -from ._models_py3 import MHSMNetworkRuleSet -from ._models_py3 import MHSMPrivateEndpoint -from ._models_py3 import MHSMPrivateEndpointConnection -from ._models_py3 import MHSMPrivateEndpointConnectionItem -from ._models_py3 import MHSMPrivateEndpointConnectionsListResult -from ._models_py3 import MHSMPrivateLinkResource -from ._models_py3 import MHSMPrivateLinkResourceListResult -from ._models_py3 import MHSMPrivateLinkServiceConnectionState -from ._models_py3 import MHSMVirtualNetworkRule -from ._models_py3 import ManagedHsm -from ._models_py3 import ManagedHsmError -from ._models_py3 import ManagedHsmListResult -from ._models_py3 import ManagedHsmProperties -from ._models_py3 import ManagedHsmResource -from ._models_py3 import ManagedHsmSku -from ._models_py3 import MetricSpecification -from ._models_py3 import NetworkRuleSet -from ._models_py3 import Operation -from ._models_py3 import OperationDisplay -from ._models_py3 import OperationListResult -from ._models_py3 import Permissions -from ._models_py3 import PrivateEndpoint -from ._models_py3 import PrivateEndpointConnection -from ._models_py3 import PrivateEndpointConnectionItem -from ._models_py3 import PrivateEndpointConnectionListResult -from ._models_py3 import PrivateLinkResource -from ._models_py3 import PrivateLinkResourceListResult -from ._models_py3 import PrivateLinkServiceConnectionState -from ._models_py3 import Resource -from ._models_py3 import ResourceListResult -from ._models_py3 import ServiceSpecification -from ._models_py3 import Sku -from ._models_py3 import SystemData -from ._models_py3 import Vault -from ._models_py3 import VaultAccessPolicyParameters -from ._models_py3 import VaultAccessPolicyProperties -from ._models_py3 import VaultCheckNameAvailabilityParameters -from ._models_py3 import VaultCreateOrUpdateParameters -from ._models_py3 import VaultListResult -from ._models_py3 import VaultPatchParameters -from ._models_py3 import VaultPatchProperties -from ._models_py3 import VaultProperties -from ._models_py3 import VirtualNetworkRule - -from ._key_vault_management_client_enums import AccessPolicyUpdateKind -from ._key_vault_management_client_enums import ActionsRequired -from ._key_vault_management_client_enums import CertificatePermissions -from ._key_vault_management_client_enums import CreateMode -from ._key_vault_management_client_enums import IdentityType -from ._key_vault_management_client_enums import KeyPermissions -from ._key_vault_management_client_enums import ManagedHsmSkuFamily -from ._key_vault_management_client_enums import ManagedHsmSkuName -from ._key_vault_management_client_enums import NetworkRuleAction -from ._key_vault_management_client_enums import NetworkRuleBypassOptions -from ._key_vault_management_client_enums import PrivateEndpointConnectionProvisioningState -from ._key_vault_management_client_enums import PrivateEndpointServiceConnectionStatus -from ._key_vault_management_client_enums import ProvisioningState -from ._key_vault_management_client_enums import PublicNetworkAccess -from ._key_vault_management_client_enums import Reason -from ._key_vault_management_client_enums import SecretPermissions -from ._key_vault_management_client_enums import SkuFamily -from ._key_vault_management_client_enums import SkuName -from ._key_vault_management_client_enums import StoragePermissions -from ._key_vault_management_client_enums import VaultProvisioningState -from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "AccessPolicyEntry", - "CheckNameAvailabilityResult", - "CloudErrorBody", - "DeletedManagedHsm", - "DeletedManagedHsmListResult", - "DeletedManagedHsmProperties", - "DeletedVault", - "DeletedVaultListResult", - "DeletedVaultProperties", - "DimensionProperties", - "Error", - "IPRule", - "LogSpecification", - "MHSMIPRule", - "MHSMNetworkRuleSet", - "MHSMPrivateEndpoint", - "MHSMPrivateEndpointConnection", - "MHSMPrivateEndpointConnectionItem", - "MHSMPrivateEndpointConnectionsListResult", - "MHSMPrivateLinkResource", - "MHSMPrivateLinkResourceListResult", - "MHSMPrivateLinkServiceConnectionState", - "MHSMVirtualNetworkRule", - "ManagedHsm", - "ManagedHsmError", - "ManagedHsmListResult", - "ManagedHsmProperties", - "ManagedHsmResource", - "ManagedHsmSku", - "MetricSpecification", - "NetworkRuleSet", - "Operation", - "OperationDisplay", - "OperationListResult", - "Permissions", - "PrivateEndpoint", - "PrivateEndpointConnection", - "PrivateEndpointConnectionItem", - "PrivateEndpointConnectionListResult", - "PrivateLinkResource", - "PrivateLinkResourceListResult", - "PrivateLinkServiceConnectionState", - "Resource", - "ResourceListResult", - "ServiceSpecification", - "Sku", - "SystemData", - "Vault", - "VaultAccessPolicyParameters", - "VaultAccessPolicyProperties", - "VaultCheckNameAvailabilityParameters", - "VaultCreateOrUpdateParameters", - "VaultListResult", - "VaultPatchParameters", - "VaultPatchProperties", - "VaultProperties", - "VirtualNetworkRule", - "AccessPolicyUpdateKind", - "ActionsRequired", - "CertificatePermissions", - "CreateMode", - "IdentityType", - "KeyPermissions", - "ManagedHsmSkuFamily", - "ManagedHsmSkuName", - "NetworkRuleAction", - "NetworkRuleBypassOptions", - "PrivateEndpointConnectionProvisioningState", - "PrivateEndpointServiceConnectionStatus", - "ProvisioningState", - "PublicNetworkAccess", - "Reason", - "SecretPermissions", - "SkuFamily", - "SkuName", - "StoragePermissions", - "VaultProvisioningState", -] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/models/_key_vault_management_client_enums.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/models/_key_vault_management_client_enums.py deleted file mode 100644 index d842e9ad2921..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/models/_key_vault_management_client_enums.py +++ /dev/null @@ -1,226 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from enum import Enum -from azure.core import CaseInsensitiveEnumMeta - - -class AccessPolicyUpdateKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """AccessPolicyUpdateKind.""" - - ADD = "add" - REPLACE = "replace" - REMOVE = "remove" - - -class ActionsRequired(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """A message indicating if changes on the service provider require any updates on the consumer.""" - - NONE = "None" - - -class CertificatePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """CertificatePermissions.""" - - GET = "get" - LIST = "list" - DELETE = "delete" - CREATE = "create" - IMPORT = "import" - UPDATE = "update" - MANAGECONTACTS = "managecontacts" - GETISSUERS = "getissuers" - LISTISSUERS = "listissuers" - SETISSUERS = "setissuers" - DELETEISSUERS = "deleteissuers" - MANAGEISSUERS = "manageissuers" - RECOVER = "recover" - PURGE = "purge" - BACKUP = "backup" - RESTORE = "restore" - IMPORT_ENUM = "import" - - -class CreateMode(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The vault's create mode to indicate whether the vault need to be recovered or not.""" - - RECOVER = "recover" - DEFAULT = "default" - - -class IdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of identity.""" - - USER = "User" - APPLICATION = "Application" - MANAGED_IDENTITY = "ManagedIdentity" - KEY = "Key" - - -class KeyPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """KeyPermissions.""" - - ENCRYPT = "encrypt" - DECRYPT = "decrypt" - WRAP_KEY = "wrapKey" - UNWRAP_KEY = "unwrapKey" - SIGN = "sign" - VERIFY = "verify" - GET = "get" - LIST = "list" - CREATE = "create" - UPDATE = "update" - IMPORT = "import" - DELETE = "delete" - BACKUP = "backup" - RESTORE = "restore" - RECOVER = "recover" - PURGE = "purge" - RELEASE = "release" - IMPORT_ENUM = "import" - - -class ManagedHsmSkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU Family of the managed HSM Pool.""" - - B = "B" - - -class ManagedHsmSkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU of the managed HSM Pool.""" - - STANDARD_B1 = "Standard_B1" - CUSTOM_B32 = "Custom_B32" - CUSTOM_B6 = "Custom_B6" - - -class NetworkRuleAction(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The default action when no rule from ipRules and from virtualNetworkRules match. This is only - used after the bypass property has been evaluated. - """ - - ALLOW = "Allow" - DENY = "Deny" - - -class NetworkRuleBypassOptions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Tells what traffic can bypass network rules. This can be 'AzureServices' or 'None'. If not - specified the default is 'AzureServices'. - """ - - AZURE_SERVICES = "AzureServices" - NONE = "None" - - -class PrivateEndpointConnectionProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The current provisioning state.""" - - SUCCEEDED = "Succeeded" - CREATING = "Creating" - UPDATING = "Updating" - DELETING = "Deleting" - FAILED = "Failed" - DISCONNECTED = "Disconnected" - - -class PrivateEndpointServiceConnectionStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The private endpoint connection status.""" - - PENDING = "Pending" - APPROVED = "Approved" - REJECTED = "Rejected" - DISCONNECTED = "Disconnected" - - -class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Provisioning state.""" - - SUCCEEDED = "Succeeded" - """The managed HSM Pool has been full provisioned.""" - PROVISIONING = "Provisioning" - """The managed HSM Pool is currently being provisioned.""" - FAILED = "Failed" - """Provisioning of the managed HSM Pool has failed.""" - UPDATING = "Updating" - """The managed HSM Pool is currently being updated.""" - DELETING = "Deleting" - """The managed HSM Pool is currently being deleted.""" - ACTIVATED = "Activated" - """The managed HSM pool is ready for normal use.""" - SECURITY_DOMAIN_RESTORE = "SecurityDomainRestore" - """The managed HSM pool is waiting for a security domain restore action.""" - RESTORING = "Restoring" - """The managed HSM pool is being restored from full HSM backup.""" - - -class PublicNetworkAccess(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Control permission to the managed HSM from public networks.""" - - ENABLED = "Enabled" - DISABLED = "Disabled" - - -class Reason(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The reason that a vault name could not be used. The Reason element is only returned if - NameAvailable is false. - """ - - ACCOUNT_NAME_INVALID = "AccountNameInvalid" - ALREADY_EXISTS = "AlreadyExists" - - -class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SecretPermissions.""" - - GET = "get" - LIST = "list" - SET = "set" - DELETE = "delete" - BACKUP = "backup" - RESTORE = "restore" - RECOVER = "recover" - PURGE = "purge" - - -class SkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU family name.""" - - A = "A" - - -class SkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU name to specify whether the key vault is a standard vault or a premium vault.""" - - STANDARD = "standard" - PREMIUM = "premium" - - -class StoragePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """StoragePermissions.""" - - GET = "get" - LIST = "list" - DELETE = "delete" - SET = "set" - UPDATE = "update" - REGENERATEKEY = "regeneratekey" - RECOVER = "recover" - PURGE = "purge" - BACKUP = "backup" - RESTORE = "restore" - SETSAS = "setsas" - LISTSAS = "listsas" - GETSAS = "getsas" - DELETESAS = "deletesas" - - -class VaultProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Provisioning state of the vault.""" - - SUCCEEDED = "Succeeded" - REGISTERING_DNS = "RegisteringDns" diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/models/_models_py3.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/models/_models_py3.py deleted file mode 100644 index 43ab135d4f36..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/models/_models_py3.py +++ /dev/null @@ -1,2887 +0,0 @@ -# coding=utf-8 -# pylint: disable=too-many-lines -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -import datetime -from typing import Any, Dict, List, Optional, TYPE_CHECKING, Union - -from ... import _serialization - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from .. import models as _models - - -class AccessPolicyEntry(_serialization.Model): - """An identity that have access to the key vault. All identities in the array must use the same - tenant ID as the key vault's tenant ID. - - All required parameters must be populated in order to send to server. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :vartype tenant_id: str - :ivar object_id: The object ID of a user, service principal or security group in the Azure - Active Directory tenant for the vault. The object ID must be unique for the list of access - policies. Required. - :vartype object_id: str - :ivar application_id: Application ID of the client making request on behalf of a principal. - :vartype application_id: str - :ivar permissions: Permissions the identity has for keys, secrets and certificates. Required. - :vartype permissions: ~azure.mgmt.keyvault.v2021_04_01_preview.models.Permissions - """ - - _validation = { - "tenant_id": {"required": True}, - "object_id": {"required": True}, - "permissions": {"required": True}, - } - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "object_id": {"key": "objectId", "type": "str"}, - "application_id": {"key": "applicationId", "type": "str"}, - "permissions": {"key": "permissions", "type": "Permissions"}, - } - - def __init__( - self, - *, - tenant_id: str, - object_id: str, - permissions: "_models.Permissions", - application_id: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :paramtype tenant_id: str - :keyword object_id: The object ID of a user, service principal or security group in the Azure - Active Directory tenant for the vault. The object ID must be unique for the list of access - policies. Required. - :paramtype object_id: str - :keyword application_id: Application ID of the client making request on behalf of a principal. - :paramtype application_id: str - :keyword permissions: Permissions the identity has for keys, secrets and certificates. - Required. - :paramtype permissions: ~azure.mgmt.keyvault.v2021_04_01_preview.models.Permissions - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.object_id = object_id - self.application_id = application_id - self.permissions = permissions - - -class CheckNameAvailabilityResult(_serialization.Model): - """The CheckNameAvailability operation response. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar name_available: A boolean value that indicates whether the name is available for you to - use. If true, the name is available. If false, the name has already been taken or is invalid - and cannot be used. - :vartype name_available: bool - :ivar reason: The reason that a vault name could not be used. The Reason element is only - returned if NameAvailable is false. Known values are: "AccountNameInvalid" and "AlreadyExists". - :vartype reason: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.Reason - :ivar message: An error message explaining the Reason value in more detail. - :vartype message: str - """ - - _validation = { - "name_available": {"readonly": True}, - "reason": {"readonly": True}, - "message": {"readonly": True}, - } - - _attribute_map = { - "name_available": {"key": "nameAvailable", "type": "bool"}, - "reason": {"key": "reason", "type": "str"}, - "message": {"key": "message", "type": "str"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.name_available = None - self.reason = None - self.message = None - - -class CloudErrorBody(_serialization.Model): - """An error response from Key Vault resource provider. - - :ivar code: Error code. This is a mnemonic that can be consumed programmatically. - :vartype code: str - :ivar message: User friendly error message. The message is typically localized and may vary - with service version. - :vartype message: str - """ - - _attribute_map = { - "code": {"key": "code", "type": "str"}, - "message": {"key": "message", "type": "str"}, - } - - def __init__(self, *, code: Optional[str] = None, message: Optional[str] = None, **kwargs: Any) -> None: - """ - :keyword code: Error code. This is a mnemonic that can be consumed programmatically. - :paramtype code: str - :keyword message: User friendly error message. The message is typically localized and may vary - with service version. - :paramtype message: str - """ - super().__init__(**kwargs) - self.code = code - self.message = message - - -class DeletedManagedHsm(_serialization.Model): - """DeletedManagedHsm. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The Azure Resource Manager resource ID for the deleted managed HSM Pool. - :vartype id: str - :ivar name: The name of the managed HSM Pool. - :vartype name: str - :ivar type: The resource type of the managed HSM Pool. - :vartype type: str - :ivar properties: Properties of the deleted managed HSM. - :vartype properties: - ~azure.mgmt.keyvault.v2021_04_01_preview.models.DeletedManagedHsmProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "properties": {"key": "properties", "type": "DeletedManagedHsmProperties"}, - } - - def __init__(self, *, properties: Optional["_models.DeletedManagedHsmProperties"] = None, **kwargs: Any) -> None: - """ - :keyword properties: Properties of the deleted managed HSM. - :paramtype properties: - ~azure.mgmt.keyvault.v2021_04_01_preview.models.DeletedManagedHsmProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.properties = properties - - -class DeletedManagedHsmListResult(_serialization.Model): - """List of deleted managed HSM Pools. - - :ivar value: The list of deleted managed HSM Pools. - :vartype value: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.DeletedManagedHsm] - :ivar next_link: The URL to get the next set of deleted managed HSM Pools. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[DeletedManagedHsm]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, - *, - value: Optional[List["_models.DeletedManagedHsm"]] = None, - next_link: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword value: The list of deleted managed HSM Pools. - :paramtype value: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.DeletedManagedHsm] - :keyword next_link: The URL to get the next set of deleted managed HSM Pools. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class DeletedManagedHsmProperties(_serialization.Model): - """Properties of the deleted managed HSM. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar mhsm_id: The resource id of the original managed HSM. - :vartype mhsm_id: str - :ivar location: The location of the original managed HSM. - :vartype location: str - :ivar deletion_date: The deleted date. - :vartype deletion_date: ~datetime.datetime - :ivar scheduled_purge_date: The scheduled purged date. - :vartype scheduled_purge_date: ~datetime.datetime - :ivar purge_protection_enabled: Purge protection status of the original managed HSM. - :vartype purge_protection_enabled: bool - :ivar tags: Tags of the original managed HSM. - :vartype tags: dict[str, str] - """ - - _validation = { - "mhsm_id": {"readonly": True}, - "location": {"readonly": True}, - "deletion_date": {"readonly": True}, - "scheduled_purge_date": {"readonly": True}, - "purge_protection_enabled": {"readonly": True}, - "tags": {"readonly": True}, - } - - _attribute_map = { - "mhsm_id": {"key": "mhsmId", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "deletion_date": {"key": "deletionDate", "type": "iso-8601"}, - "scheduled_purge_date": {"key": "scheduledPurgeDate", "type": "iso-8601"}, - "purge_protection_enabled": {"key": "purgeProtectionEnabled", "type": "bool"}, - "tags": {"key": "tags", "type": "{str}"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.mhsm_id = None - self.location = None - self.deletion_date = None - self.scheduled_purge_date = None - self.purge_protection_enabled = None - self.tags = None - - -class DeletedVault(_serialization.Model): - """Deleted vault information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The resource ID for the deleted key vault. - :vartype id: str - :ivar name: The name of the key vault. - :vartype name: str - :ivar type: The resource type of the key vault. - :vartype type: str - :ivar properties: Properties of the vault. - :vartype properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.DeletedVaultProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "properties": {"key": "properties", "type": "DeletedVaultProperties"}, - } - - def __init__(self, *, properties: Optional["_models.DeletedVaultProperties"] = None, **kwargs: Any) -> None: - """ - :keyword properties: Properties of the vault. - :paramtype properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.DeletedVaultProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.properties = properties - - -class DeletedVaultListResult(_serialization.Model): - """List of vaults. - - :ivar value: The list of deleted vaults. - :vartype value: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.DeletedVault] - :ivar next_link: The URL to get the next set of deleted vaults. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[DeletedVault]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.DeletedVault"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of deleted vaults. - :paramtype value: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.DeletedVault] - :keyword next_link: The URL to get the next set of deleted vaults. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class DeletedVaultProperties(_serialization.Model): - """Properties of the deleted vault. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar vault_id: The resource id of the original vault. - :vartype vault_id: str - :ivar location: The location of the original vault. - :vartype location: str - :ivar deletion_date: The deleted date. - :vartype deletion_date: ~datetime.datetime - :ivar scheduled_purge_date: The scheduled purged date. - :vartype scheduled_purge_date: ~datetime.datetime - :ivar tags: Tags of the original vault. - :vartype tags: dict[str, str] - :ivar purge_protection_enabled: Purge protection status of the original vault. - :vartype purge_protection_enabled: bool - """ - - _validation = { - "vault_id": {"readonly": True}, - "location": {"readonly": True}, - "deletion_date": {"readonly": True}, - "scheduled_purge_date": {"readonly": True}, - "tags": {"readonly": True}, - "purge_protection_enabled": {"readonly": True}, - } - - _attribute_map = { - "vault_id": {"key": "vaultId", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "deletion_date": {"key": "deletionDate", "type": "iso-8601"}, - "scheduled_purge_date": {"key": "scheduledPurgeDate", "type": "iso-8601"}, - "tags": {"key": "tags", "type": "{str}"}, - "purge_protection_enabled": {"key": "purgeProtectionEnabled", "type": "bool"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.vault_id = None - self.location = None - self.deletion_date = None - self.scheduled_purge_date = None - self.tags = None - self.purge_protection_enabled = None - - -class DimensionProperties(_serialization.Model): - """Type of operation: get, read, delete, etc. - - :ivar name: Name of dimension. - :vartype name: str - :ivar display_name: Display name of dimension. - :vartype display_name: str - :ivar to_be_exported_for_shoebox: Property to specify whether the dimension should be exported - for Shoebox. - :vartype to_be_exported_for_shoebox: bool - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display_name": {"key": "displayName", "type": "str"}, - "to_be_exported_for_shoebox": {"key": "toBeExportedForShoebox", "type": "bool"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display_name: Optional[str] = None, - to_be_exported_for_shoebox: Optional[bool] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Name of dimension. - :paramtype name: str - :keyword display_name: Display name of dimension. - :paramtype display_name: str - :keyword to_be_exported_for_shoebox: Property to specify whether the dimension should be - exported for Shoebox. - :paramtype to_be_exported_for_shoebox: bool - """ - super().__init__(**kwargs) - self.name = name - self.display_name = display_name - self.to_be_exported_for_shoebox = to_be_exported_for_shoebox - - -class Error(_serialization.Model): - """The server error. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar code: The error code. - :vartype code: str - :ivar message: The error message. - :vartype message: str - :ivar inner_error: The inner error, contains a more specific error code. - :vartype inner_error: ~azure.mgmt.keyvault.v2021_04_01_preview.models.Error - """ - - _validation = { - "code": {"readonly": True}, - "message": {"readonly": True}, - "inner_error": {"readonly": True}, - } - - _attribute_map = { - "code": {"key": "code", "type": "str"}, - "message": {"key": "message", "type": "str"}, - "inner_error": {"key": "innererror", "type": "Error"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.code = None - self.message = None - self.inner_error = None - - -class IPRule(_serialization.Model): - """A rule governing the accessibility of a vault from a specific ip address or ip range. - - All required parameters must be populated in order to send to server. - - :ivar value: An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP address) - or '124.56.78.0/24' (all addresses that start with 124.56.78). Required. - :vartype value: str - """ - - _validation = { - "value": {"required": True}, - } - - _attribute_map = { - "value": {"key": "value", "type": "str"}, - } - - def __init__(self, *, value: str, **kwargs: Any) -> None: - """ - :keyword value: An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP - address) or '124.56.78.0/24' (all addresses that start with 124.56.78). Required. - :paramtype value: str - """ - super().__init__(**kwargs) - self.value = value - - -class LogSpecification(_serialization.Model): - """Log specification of operation. - - :ivar name: Name of log specification. - :vartype name: str - :ivar display_name: Display name of log specification. - :vartype display_name: str - :ivar blob_duration: Blob duration of specification. - :vartype blob_duration: str - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display_name": {"key": "displayName", "type": "str"}, - "blob_duration": {"key": "blobDuration", "type": "str"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display_name: Optional[str] = None, - blob_duration: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Name of log specification. - :paramtype name: str - :keyword display_name: Display name of log specification. - :paramtype display_name: str - :keyword blob_duration: Blob duration of specification. - :paramtype blob_duration: str - """ - super().__init__(**kwargs) - self.name = name - self.display_name = display_name - self.blob_duration = blob_duration - - -class ManagedHsmResource(_serialization.Model): - """Managed HSM resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The Azure Resource Manager resource ID for the managed HSM Pool. - :vartype id: str - :ivar name: The name of the managed HSM Pool. - :vartype name: str - :ivar type: The resource type of the managed HSM Pool. - :vartype type: str - :ivar location: The supported Azure location where the managed HSM Pool should be created. - :vartype location: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSku - :ivar tags: Resource tags. - :vartype tags: dict[str, str] - :ivar system_data: Metadata pertaining to creation and last modification of the key vault - resource. - :vartype system_data: ~azure.mgmt.keyvault.v2021_04_01_preview.models.SystemData - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "system_data": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "sku": {"key": "sku", "type": "ManagedHsmSku"}, - "tags": {"key": "tags", "type": "{str}"}, - "system_data": {"key": "systemData", "type": "SystemData"}, - } - - def __init__( - self, - *, - location: Optional[str] = None, - sku: Optional["_models.ManagedHsmSku"] = None, - tags: Optional[Dict[str, str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the managed HSM Pool should be created. - :paramtype location: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSku - :keyword tags: Resource tags. - :paramtype tags: dict[str, str] - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = location - self.sku = sku - self.tags = tags - self.system_data = None - - -class ManagedHsm(ManagedHsmResource): - """Resource information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The Azure Resource Manager resource ID for the managed HSM Pool. - :vartype id: str - :ivar name: The name of the managed HSM Pool. - :vartype name: str - :ivar type: The resource type of the managed HSM Pool. - :vartype type: str - :ivar location: The supported Azure location where the managed HSM Pool should be created. - :vartype location: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSku - :ivar tags: Resource tags. - :vartype tags: dict[str, str] - :ivar system_data: Metadata pertaining to creation and last modification of the key vault - resource. - :vartype system_data: ~azure.mgmt.keyvault.v2021_04_01_preview.models.SystemData - :ivar properties: Properties of the managed HSM. - :vartype properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "system_data": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "sku": {"key": "sku", "type": "ManagedHsmSku"}, - "tags": {"key": "tags", "type": "{str}"}, - "system_data": {"key": "systemData", "type": "SystemData"}, - "properties": {"key": "properties", "type": "ManagedHsmProperties"}, - } - - def __init__( - self, - *, - location: Optional[str] = None, - sku: Optional["_models.ManagedHsmSku"] = None, - tags: Optional[Dict[str, str]] = None, - properties: Optional["_models.ManagedHsmProperties"] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the managed HSM Pool should be created. - :paramtype location: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSku - :keyword tags: Resource tags. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the managed HSM. - :paramtype properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmProperties - """ - super().__init__(location=location, sku=sku, tags=tags, **kwargs) - self.properties = properties - - -class ManagedHsmError(_serialization.Model): - """The error exception. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar error: The server error. - :vartype error: ~azure.mgmt.keyvault.v2021_04_01_preview.models.Error - """ - - _validation = { - "error": {"readonly": True}, - } - - _attribute_map = { - "error": {"key": "error", "type": "Error"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.error = None - - -class ManagedHsmListResult(_serialization.Model): - """List of managed HSM Pools. - - :ivar value: The list of managed HSM Pools. - :vartype value: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm] - :ivar next_link: The URL to get the next set of managed HSM Pools. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[ManagedHsm]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.ManagedHsm"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of managed HSM Pools. - :paramtype value: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm] - :keyword next_link: The URL to get the next set of managed HSM Pools. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class ManagedHsmProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Properties of the managed HSM Pool. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the managed HSM pool. - :vartype tenant_id: str - :ivar initial_admin_object_ids: Array of initial administrators object ids for this managed hsm - pool. - :vartype initial_admin_object_ids: list[str] - :ivar hsm_uri: The URI of the managed hsm pool for performing operations on keys. - :vartype hsm_uri: str - :ivar enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this managed HSM pool. Soft delete is enabled by default for all managed HSMs and - is immutable. - :vartype enable_soft_delete: bool - :ivar soft_delete_retention_in_days: Soft deleted data retention days. When you delete an HSM - or a key, it will remain recoverable for the configured retention period or for a default - period of 90 days. It accepts values between 7 and 90. - :vartype soft_delete_retention_in_days: int - :ivar enable_purge_protection: Property specifying whether protection against purge is enabled - for this managed HSM pool. Setting this property to true activates protection against purge for - this managed HSM pool and its content - only the Managed HSM service may initiate a hard, - irrecoverable deletion. Enabling this functionality is irreversible. - :vartype enable_purge_protection: bool - :ivar create_mode: The create mode to indicate whether the resource is being created or is - being recovered from a deleted resource. Known values are: "recover" and "default". - :vartype create_mode: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.CreateMode - :ivar status_message: Resource Status Message. - :vartype status_message: str - :ivar provisioning_state: Provisioning state. Known values are: "Succeeded", "Provisioning", - "Failed", "Updating", "Deleting", "Activated", "SecurityDomainRestore", and "Restoring". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.ProvisioningState - :ivar network_acls: Rules governing the accessibility of the key vault from specific network - locations. - :vartype network_acls: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMNetworkRuleSet - :ivar private_endpoint_connections: List of private endpoint connections associated with the - managed hsm pool. - :vartype private_endpoint_connections: - list[~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnectionItem] - :ivar public_network_access: Control permission to the managed HSM from public networks. Known - values are: "Enabled" and "Disabled". - :vartype public_network_access: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.PublicNetworkAccess - :ivar scheduled_purge_date: The scheduled purge date in UTC. - :vartype scheduled_purge_date: ~datetime.datetime - """ - - _validation = { - "hsm_uri": {"readonly": True}, - "status_message": {"readonly": True}, - "provisioning_state": {"readonly": True}, - "private_endpoint_connections": {"readonly": True}, - "scheduled_purge_date": {"readonly": True}, - } - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "initial_admin_object_ids": {"key": "initialAdminObjectIds", "type": "[str]"}, - "hsm_uri": {"key": "hsmUri", "type": "str"}, - "enable_soft_delete": {"key": "enableSoftDelete", "type": "bool"}, - "soft_delete_retention_in_days": {"key": "softDeleteRetentionInDays", "type": "int"}, - "enable_purge_protection": {"key": "enablePurgeProtection", "type": "bool"}, - "create_mode": {"key": "createMode", "type": "str"}, - "status_message": {"key": "statusMessage", "type": "str"}, - "provisioning_state": {"key": "provisioningState", "type": "str"}, - "network_acls": {"key": "networkAcls", "type": "MHSMNetworkRuleSet"}, - "private_endpoint_connections": { - "key": "privateEndpointConnections", - "type": "[MHSMPrivateEndpointConnectionItem]", - }, - "public_network_access": {"key": "publicNetworkAccess", "type": "str"}, - "scheduled_purge_date": {"key": "scheduledPurgeDate", "type": "iso-8601"}, - } - - def __init__( - self, - *, - tenant_id: Optional[str] = None, - initial_admin_object_ids: Optional[List[str]] = None, - enable_soft_delete: bool = True, - soft_delete_retention_in_days: int = 90, - enable_purge_protection: bool = True, - create_mode: Optional[Union[str, "_models.CreateMode"]] = None, - network_acls: Optional["_models.MHSMNetworkRuleSet"] = None, - public_network_access: Union[str, "_models.PublicNetworkAccess"] = "Enabled", - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the managed HSM pool. - :paramtype tenant_id: str - :keyword initial_admin_object_ids: Array of initial administrators object ids for this managed - hsm pool. - :paramtype initial_admin_object_ids: list[str] - :keyword enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this managed HSM pool. Soft delete is enabled by default for all managed HSMs and - is immutable. - :paramtype enable_soft_delete: bool - :keyword soft_delete_retention_in_days: Soft deleted data retention days. When you delete an - HSM or a key, it will remain recoverable for the configured retention period or for a default - period of 90 days. It accepts values between 7 and 90. - :paramtype soft_delete_retention_in_days: int - :keyword enable_purge_protection: Property specifying whether protection against purge is - enabled for this managed HSM pool. Setting this property to true activates protection against - purge for this managed HSM pool and its content - only the Managed HSM service may initiate a - hard, irrecoverable deletion. Enabling this functionality is irreversible. - :paramtype enable_purge_protection: bool - :keyword create_mode: The create mode to indicate whether the resource is being created or is - being recovered from a deleted resource. Known values are: "recover" and "default". - :paramtype create_mode: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.CreateMode - :keyword network_acls: Rules governing the accessibility of the key vault from specific network - locations. - :paramtype network_acls: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMNetworkRuleSet - :keyword public_network_access: Control permission to the managed HSM from public networks. - Known values are: "Enabled" and "Disabled". - :paramtype public_network_access: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.PublicNetworkAccess - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.initial_admin_object_ids = initial_admin_object_ids - self.hsm_uri = None - self.enable_soft_delete = enable_soft_delete - self.soft_delete_retention_in_days = soft_delete_retention_in_days - self.enable_purge_protection = enable_purge_protection - self.create_mode = create_mode - self.status_message = None - self.provisioning_state = None - self.network_acls = network_acls - self.private_endpoint_connections = None - self.public_network_access = public_network_access - self.scheduled_purge_date = None - - -class ManagedHsmSku(_serialization.Model): - """SKU details. - - All required parameters must be populated in order to send to server. - - :ivar family: SKU Family of the managed HSM Pool. "B" - :vartype family: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSkuFamily - :ivar name: SKU of the managed HSM Pool. Required. Known values are: "Standard_B1", - "Custom_B32", and "Custom_B6". - :vartype name: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSkuName - """ - - _validation = { - "family": {"required": True}, - "name": {"required": True}, - } - - _attribute_map = { - "family": {"key": "family", "type": "str"}, - "name": {"key": "name", "type": "str"}, - } - - def __init__( - self, - *, - family: Union[str, "_models.ManagedHsmSkuFamily"] = "B", - name: Union[str, "_models.ManagedHsmSkuName"], - **kwargs: Any - ) -> None: - """ - :keyword family: SKU Family of the managed HSM Pool. "B" - :paramtype family: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSkuFamily - :keyword name: SKU of the managed HSM Pool. Required. Known values are: "Standard_B1", - "Custom_B32", and "Custom_B6". - :paramtype name: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSkuName - """ - super().__init__(**kwargs) - self.family = family - self.name = name - - -class MetricSpecification(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Metric specification of operation. - - :ivar name: Name of metric specification. - :vartype name: str - :ivar display_name: Display name of metric specification. - :vartype display_name: str - :ivar display_description: Display description of metric specification. - :vartype display_description: str - :ivar unit: The metric unit. Possible values include: 'Bytes', 'Count', 'Milliseconds'. - :vartype unit: str - :ivar aggregation_type: The metric aggregation type. Possible values include: 'Average', - 'Count', 'Total'. - :vartype aggregation_type: str - :ivar supported_aggregation_types: The supported aggregation types for the metrics. - :vartype supported_aggregation_types: list[str] - :ivar supported_time_grain_types: The supported time grain types for the metrics. - :vartype supported_time_grain_types: list[str] - :ivar lock_aggregation_type: The metric lock aggregation type. - :vartype lock_aggregation_type: str - :ivar dimensions: The dimensions of metric. - :vartype dimensions: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.DimensionProperties] - :ivar fill_gap_with_zero: Property to specify whether to fill gap with zero. - :vartype fill_gap_with_zero: bool - :ivar internal_metric_name: The internal metric name. - :vartype internal_metric_name: str - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display_name": {"key": "displayName", "type": "str"}, - "display_description": {"key": "displayDescription", "type": "str"}, - "unit": {"key": "unit", "type": "str"}, - "aggregation_type": {"key": "aggregationType", "type": "str"}, - "supported_aggregation_types": {"key": "supportedAggregationTypes", "type": "[str]"}, - "supported_time_grain_types": {"key": "supportedTimeGrainTypes", "type": "[str]"}, - "lock_aggregation_type": {"key": "lockAggregationType", "type": "str"}, - "dimensions": {"key": "dimensions", "type": "[DimensionProperties]"}, - "fill_gap_with_zero": {"key": "fillGapWithZero", "type": "bool"}, - "internal_metric_name": {"key": "internalMetricName", "type": "str"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display_name: Optional[str] = None, - display_description: Optional[str] = None, - unit: Optional[str] = None, - aggregation_type: Optional[str] = None, - supported_aggregation_types: Optional[List[str]] = None, - supported_time_grain_types: Optional[List[str]] = None, - lock_aggregation_type: Optional[str] = None, - dimensions: Optional[List["_models.DimensionProperties"]] = None, - fill_gap_with_zero: Optional[bool] = None, - internal_metric_name: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Name of metric specification. - :paramtype name: str - :keyword display_name: Display name of metric specification. - :paramtype display_name: str - :keyword display_description: Display description of metric specification. - :paramtype display_description: str - :keyword unit: The metric unit. Possible values include: 'Bytes', 'Count', 'Milliseconds'. - :paramtype unit: str - :keyword aggregation_type: The metric aggregation type. Possible values include: 'Average', - 'Count', 'Total'. - :paramtype aggregation_type: str - :keyword supported_aggregation_types: The supported aggregation types for the metrics. - :paramtype supported_aggregation_types: list[str] - :keyword supported_time_grain_types: The supported time grain types for the metrics. - :paramtype supported_time_grain_types: list[str] - :keyword lock_aggregation_type: The metric lock aggregation type. - :paramtype lock_aggregation_type: str - :keyword dimensions: The dimensions of metric. - :paramtype dimensions: - list[~azure.mgmt.keyvault.v2021_04_01_preview.models.DimensionProperties] - :keyword fill_gap_with_zero: Property to specify whether to fill gap with zero. - :paramtype fill_gap_with_zero: bool - :keyword internal_metric_name: The internal metric name. - :paramtype internal_metric_name: str - """ - super().__init__(**kwargs) - self.name = name - self.display_name = display_name - self.display_description = display_description - self.unit = unit - self.aggregation_type = aggregation_type - self.supported_aggregation_types = supported_aggregation_types - self.supported_time_grain_types = supported_time_grain_types - self.lock_aggregation_type = lock_aggregation_type - self.dimensions = dimensions - self.fill_gap_with_zero = fill_gap_with_zero - self.internal_metric_name = internal_metric_name - - -class MHSMIPRule(_serialization.Model): - """A rule governing the accessibility of a managed hsm pool from a specific ip address or ip - range. - - All required parameters must be populated in order to send to server. - - :ivar value: An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP address) - or '124.56.78.0/24' (all addresses that start with 124.56.78). Required. - :vartype value: str - """ - - _validation = { - "value": {"required": True}, - } - - _attribute_map = { - "value": {"key": "value", "type": "str"}, - } - - def __init__(self, *, value: str, **kwargs: Any) -> None: - """ - :keyword value: An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP - address) or '124.56.78.0/24' (all addresses that start with 124.56.78). Required. - :paramtype value: str - """ - super().__init__(**kwargs) - self.value = value - - -class MHSMNetworkRuleSet(_serialization.Model): - """A set of rules governing the network accessibility of a managed hsm pool. - - :ivar bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or - 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and - "None". - :vartype bypass: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.NetworkRuleBypassOptions - :ivar default_action: The default action when no rule from ipRules and from virtualNetworkRules - match. This is only used after the bypass property has been evaluated. Known values are: - "Allow" and "Deny". - :vartype default_action: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.NetworkRuleAction - :ivar ip_rules: The list of IP address rules. - :vartype ip_rules: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMIPRule] - :ivar virtual_network_rules: The list of virtual network rules. - :vartype virtual_network_rules: - list[~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMVirtualNetworkRule] - """ - - _attribute_map = { - "bypass": {"key": "bypass", "type": "str"}, - "default_action": {"key": "defaultAction", "type": "str"}, - "ip_rules": {"key": "ipRules", "type": "[MHSMIPRule]"}, - "virtual_network_rules": {"key": "virtualNetworkRules", "type": "[MHSMVirtualNetworkRule]"}, - } - - def __init__( - self, - *, - bypass: Optional[Union[str, "_models.NetworkRuleBypassOptions"]] = None, - default_action: Optional[Union[str, "_models.NetworkRuleAction"]] = None, - ip_rules: Optional[List["_models.MHSMIPRule"]] = None, - virtual_network_rules: Optional[List["_models.MHSMVirtualNetworkRule"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or - 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and - "None". - :paramtype bypass: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.NetworkRuleBypassOptions - :keyword default_action: The default action when no rule from ipRules and from - virtualNetworkRules match. This is only used after the bypass property has been evaluated. - Known values are: "Allow" and "Deny". - :paramtype default_action: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.NetworkRuleAction - :keyword ip_rules: The list of IP address rules. - :paramtype ip_rules: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMIPRule] - :keyword virtual_network_rules: The list of virtual network rules. - :paramtype virtual_network_rules: - list[~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMVirtualNetworkRule] - """ - super().__init__(**kwargs) - self.bypass = bypass - self.default_action = default_action - self.ip_rules = ip_rules - self.virtual_network_rules = virtual_network_rules - - -class MHSMPrivateEndpoint(_serialization.Model): - """Private endpoint object properties. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Full identifier of the private endpoint resource. - :vartype id: str - """ - - _validation = { - "id": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.id = None - - -class MHSMPrivateEndpointConnection(ManagedHsmResource): # pylint: disable=too-many-instance-attributes - """Private endpoint connection resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The Azure Resource Manager resource ID for the managed HSM Pool. - :vartype id: str - :ivar name: The name of the managed HSM Pool. - :vartype name: str - :ivar type: The resource type of the managed HSM Pool. - :vartype type: str - :ivar location: The supported Azure location where the managed HSM Pool should be created. - :vartype location: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSku - :ivar tags: Resource tags. - :vartype tags: dict[str, str] - :ivar system_data: Metadata pertaining to creation and last modification of the key vault - resource. - :vartype system_data: ~azure.mgmt.keyvault.v2021_04_01_preview.models.SystemData - :ivar etag: Modified whenever there is a change in the state of private endpoint connection. - :vartype etag: str - :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpoint - :ivar private_link_service_connection_state: Approval state of the private link connection. - :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateLinkServiceConnectionState - :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values - are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnectionProvisioningState - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "system_data": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "sku": {"key": "sku", "type": "ManagedHsmSku"}, - "tags": {"key": "tags", "type": "{str}"}, - "system_data": {"key": "systemData", "type": "SystemData"}, - "etag": {"key": "etag", "type": "str"}, - "private_endpoint": {"key": "properties.privateEndpoint", "type": "MHSMPrivateEndpoint"}, - "private_link_service_connection_state": { - "key": "properties.privateLinkServiceConnectionState", - "type": "MHSMPrivateLinkServiceConnectionState", - }, - "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - location: Optional[str] = None, - sku: Optional["_models.ManagedHsmSku"] = None, - tags: Optional[Dict[str, str]] = None, - etag: Optional[str] = None, - private_endpoint: Optional["_models.MHSMPrivateEndpoint"] = None, - private_link_service_connection_state: Optional["_models.MHSMPrivateLinkServiceConnectionState"] = None, - provisioning_state: Optional[Union[str, "_models.PrivateEndpointConnectionProvisioningState"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the managed HSM Pool should be created. - :paramtype location: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSku - :keyword tags: Resource tags. - :paramtype tags: dict[str, str] - :keyword etag: Modified whenever there is a change in the state of private endpoint connection. - :paramtype etag: str - :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: - ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpoint - :keyword private_link_service_connection_state: Approval state of the private link connection. - :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateLinkServiceConnectionState - :keyword provisioning_state: Provisioning state of the private endpoint connection. Known - values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnectionProvisioningState - """ - super().__init__(location=location, sku=sku, tags=tags, **kwargs) - self.etag = etag - self.private_endpoint = private_endpoint - self.private_link_service_connection_state = private_link_service_connection_state - self.provisioning_state = provisioning_state - - -class MHSMPrivateEndpointConnectionItem(_serialization.Model): - """Private endpoint connection item. - - :ivar id: Id of private endpoint connection. - :vartype id: str - :ivar etag: Modified whenever there is a change in the state of private endpoint connection. - :vartype etag: str - :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpoint - :ivar private_link_service_connection_state: Approval state of the private link connection. - :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateLinkServiceConnectionState - :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values - are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnectionProvisioningState - """ - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "etag": {"key": "etag", "type": "str"}, - "private_endpoint": {"key": "properties.privateEndpoint", "type": "MHSMPrivateEndpoint"}, - "private_link_service_connection_state": { - "key": "properties.privateLinkServiceConnectionState", - "type": "MHSMPrivateLinkServiceConnectionState", - }, - "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - id: Optional[str] = None, # pylint: disable=redefined-builtin - etag: Optional[str] = None, - private_endpoint: Optional["_models.MHSMPrivateEndpoint"] = None, - private_link_service_connection_state: Optional["_models.MHSMPrivateLinkServiceConnectionState"] = None, - provisioning_state: Optional[Union[str, "_models.PrivateEndpointConnectionProvisioningState"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword id: Id of private endpoint connection. - :paramtype id: str - :keyword etag: Modified whenever there is a change in the state of private endpoint connection. - :paramtype etag: str - :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: - ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpoint - :keyword private_link_service_connection_state: Approval state of the private link connection. - :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateLinkServiceConnectionState - :keyword provisioning_state: Provisioning state of the private endpoint connection. Known - values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnectionProvisioningState - """ - super().__init__(**kwargs) - self.id = id - self.etag = etag - self.private_endpoint = private_endpoint - self.private_link_service_connection_state = private_link_service_connection_state - self.provisioning_state = provisioning_state - - -class MHSMPrivateEndpointConnectionsListResult(_serialization.Model): - """List of private endpoint connections associated with a managed HSM Pools. - - :ivar value: The private endpoint connection associated with a managed HSM Pools. - :vartype value: - list[~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection] - :ivar next_link: The URL to get the next set of managed HSM Pools. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[MHSMPrivateEndpointConnection]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, - *, - value: Optional[List["_models.MHSMPrivateEndpointConnection"]] = None, - next_link: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword value: The private endpoint connection associated with a managed HSM Pools. - :paramtype value: - list[~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection] - :keyword next_link: The URL to get the next set of managed HSM Pools. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class MHSMPrivateLinkResource(ManagedHsmResource): - """A private link resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The Azure Resource Manager resource ID for the managed HSM Pool. - :vartype id: str - :ivar name: The name of the managed HSM Pool. - :vartype name: str - :ivar type: The resource type of the managed HSM Pool. - :vartype type: str - :ivar location: The supported Azure location where the managed HSM Pool should be created. - :vartype location: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSku - :ivar tags: Resource tags. - :vartype tags: dict[str, str] - :ivar system_data: Metadata pertaining to creation and last modification of the key vault - resource. - :vartype system_data: ~azure.mgmt.keyvault.v2021_04_01_preview.models.SystemData - :ivar group_id: Group identifier of private link resource. - :vartype group_id: str - :ivar required_members: Required member names of private link resource. - :vartype required_members: list[str] - :ivar required_zone_names: Required DNS zone names of the the private link resource. - :vartype required_zone_names: list[str] - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "system_data": {"readonly": True}, - "group_id": {"readonly": True}, - "required_members": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "sku": {"key": "sku", "type": "ManagedHsmSku"}, - "tags": {"key": "tags", "type": "{str}"}, - "system_data": {"key": "systemData", "type": "SystemData"}, - "group_id": {"key": "properties.groupId", "type": "str"}, - "required_members": {"key": "properties.requiredMembers", "type": "[str]"}, - "required_zone_names": {"key": "properties.requiredZoneNames", "type": "[str]"}, - } - - def __init__( - self, - *, - location: Optional[str] = None, - sku: Optional["_models.ManagedHsmSku"] = None, - tags: Optional[Dict[str, str]] = None, - required_zone_names: Optional[List[str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the managed HSM Pool should be created. - :paramtype location: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSku - :keyword tags: Resource tags. - :paramtype tags: dict[str, str] - :keyword required_zone_names: Required DNS zone names of the the private link resource. - :paramtype required_zone_names: list[str] - """ - super().__init__(location=location, sku=sku, tags=tags, **kwargs) - self.group_id = None - self.required_members = None - self.required_zone_names = required_zone_names - - -class MHSMPrivateLinkResourceListResult(_serialization.Model): - """A list of private link resources. - - :ivar value: Array of private link resources. - :vartype value: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateLinkResource] - """ - - _attribute_map = { - "value": {"key": "value", "type": "[MHSMPrivateLinkResource]"}, - } - - def __init__(self, *, value: Optional[List["_models.MHSMPrivateLinkResource"]] = None, **kwargs: Any) -> None: - """ - :keyword value: Array of private link resources. - :paramtype value: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateLinkResource] - """ - super().__init__(**kwargs) - self.value = value - - -class MHSMPrivateLinkServiceConnectionState(_serialization.Model): - """An object that represents the approval state of the private link connection. - - :ivar status: Indicates whether the connection has been approved, rejected or removed by the - key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :vartype status: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointServiceConnectionStatus - :ivar description: The reason for approval or rejection. - :vartype description: str - :ivar actions_required: A message indicating if changes on the service provider require any - updates on the consumer. "None" - :vartype actions_required: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.ActionsRequired - """ - - _attribute_map = { - "status": {"key": "status", "type": "str"}, - "description": {"key": "description", "type": "str"}, - "actions_required": {"key": "actionsRequired", "type": "str"}, - } - - def __init__( - self, - *, - status: Optional[Union[str, "_models.PrivateEndpointServiceConnectionStatus"]] = None, - description: Optional[str] = None, - actions_required: Optional[Union[str, "_models.ActionsRequired"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword status: Indicates whether the connection has been approved, rejected or removed by the - key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :paramtype status: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointServiceConnectionStatus - :keyword description: The reason for approval or rejection. - :paramtype description: str - :keyword actions_required: A message indicating if changes on the service provider require any - updates on the consumer. "None" - :paramtype actions_required: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.ActionsRequired - """ - super().__init__(**kwargs) - self.status = status - self.description = description - self.actions_required = actions_required - - -class MHSMVirtualNetworkRule(_serialization.Model): - """A rule governing the accessibility of a managed hsm pool from a specific virtual network. - - All required parameters must be populated in order to send to server. - - :ivar id: Full resource id of a vnet subnet, such as - '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. - Required. - :vartype id: str - """ - - _validation = { - "id": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - } - - def __init__(self, *, id: str, **kwargs: Any) -> None: # pylint: disable=redefined-builtin - """ - :keyword id: Full resource id of a vnet subnet, such as - '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. # pylint: disable=line-too-long - Required. - :paramtype id: str - """ - super().__init__(**kwargs) - self.id = id - - -class NetworkRuleSet(_serialization.Model): - """A set of rules governing the network accessibility of a vault. - - :ivar bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or - 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and - "None". - :vartype bypass: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.NetworkRuleBypassOptions - :ivar default_action: The default action when no rule from ipRules and from virtualNetworkRules - match. This is only used after the bypass property has been evaluated. Known values are: - "Allow" and "Deny". - :vartype default_action: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.NetworkRuleAction - :ivar ip_rules: The list of IP address rules. - :vartype ip_rules: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.IPRule] - :ivar virtual_network_rules: The list of virtual network rules. - :vartype virtual_network_rules: - list[~azure.mgmt.keyvault.v2021_04_01_preview.models.VirtualNetworkRule] - """ - - _attribute_map = { - "bypass": {"key": "bypass", "type": "str"}, - "default_action": {"key": "defaultAction", "type": "str"}, - "ip_rules": {"key": "ipRules", "type": "[IPRule]"}, - "virtual_network_rules": {"key": "virtualNetworkRules", "type": "[VirtualNetworkRule]"}, - } - - def __init__( - self, - *, - bypass: Optional[Union[str, "_models.NetworkRuleBypassOptions"]] = None, - default_action: Optional[Union[str, "_models.NetworkRuleAction"]] = None, - ip_rules: Optional[List["_models.IPRule"]] = None, - virtual_network_rules: Optional[List["_models.VirtualNetworkRule"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or - 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and - "None". - :paramtype bypass: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.NetworkRuleBypassOptions - :keyword default_action: The default action when no rule from ipRules and from - virtualNetworkRules match. This is only used after the bypass property has been evaluated. - Known values are: "Allow" and "Deny". - :paramtype default_action: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.NetworkRuleAction - :keyword ip_rules: The list of IP address rules. - :paramtype ip_rules: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.IPRule] - :keyword virtual_network_rules: The list of virtual network rules. - :paramtype virtual_network_rules: - list[~azure.mgmt.keyvault.v2021_04_01_preview.models.VirtualNetworkRule] - """ - super().__init__(**kwargs) - self.bypass = bypass - self.default_action = default_action - self.ip_rules = ip_rules - self.virtual_network_rules = virtual_network_rules - - -class Operation(_serialization.Model): - """Key Vault REST API operation definition. - - :ivar name: Operation name: {provider}/{resource}/{operation}. - :vartype name: str - :ivar display: Display metadata associated with the operation. - :vartype display: ~azure.mgmt.keyvault.v2021_04_01_preview.models.OperationDisplay - :ivar origin: The origin of operations. - :vartype origin: str - :ivar is_data_action: Property to specify whether the action is a data action. - :vartype is_data_action: bool - :ivar service_specification: One property of operation, include metric specifications. - :vartype service_specification: - ~azure.mgmt.keyvault.v2021_04_01_preview.models.ServiceSpecification - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display": {"key": "display", "type": "OperationDisplay"}, - "origin": {"key": "origin", "type": "str"}, - "is_data_action": {"key": "isDataAction", "type": "bool"}, - "service_specification": {"key": "properties.serviceSpecification", "type": "ServiceSpecification"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display: Optional["_models.OperationDisplay"] = None, - origin: Optional[str] = None, - is_data_action: Optional[bool] = None, - service_specification: Optional["_models.ServiceSpecification"] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Operation name: {provider}/{resource}/{operation}. - :paramtype name: str - :keyword display: Display metadata associated with the operation. - :paramtype display: ~azure.mgmt.keyvault.v2021_04_01_preview.models.OperationDisplay - :keyword origin: The origin of operations. - :paramtype origin: str - :keyword is_data_action: Property to specify whether the action is a data action. - :paramtype is_data_action: bool - :keyword service_specification: One property of operation, include metric specifications. - :paramtype service_specification: - ~azure.mgmt.keyvault.v2021_04_01_preview.models.ServiceSpecification - """ - super().__init__(**kwargs) - self.name = name - self.display = display - self.origin = origin - self.is_data_action = is_data_action - self.service_specification = service_specification - - -class OperationDisplay(_serialization.Model): - """Display metadata associated with the operation. - - :ivar provider: Service provider: Microsoft Key Vault. - :vartype provider: str - :ivar resource: Resource on which the operation is performed etc. - :vartype resource: str - :ivar operation: Type of operation: get, read, delete, etc. - :vartype operation: str - :ivar description: Description of operation. - :vartype description: str - """ - - _attribute_map = { - "provider": {"key": "provider", "type": "str"}, - "resource": {"key": "resource", "type": "str"}, - "operation": {"key": "operation", "type": "str"}, - "description": {"key": "description", "type": "str"}, - } - - def __init__( - self, - *, - provider: Optional[str] = None, - resource: Optional[str] = None, - operation: Optional[str] = None, - description: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword provider: Service provider: Microsoft Key Vault. - :paramtype provider: str - :keyword resource: Resource on which the operation is performed etc. - :paramtype resource: str - :keyword operation: Type of operation: get, read, delete, etc. - :paramtype operation: str - :keyword description: Description of operation. - :paramtype description: str - """ - super().__init__(**kwargs) - self.provider = provider - self.resource = resource - self.operation = operation - self.description = description - - -class OperationListResult(_serialization.Model): - """Result of the request to list Storage operations. It contains a list of operations and a URL - link to get the next set of results. - - :ivar value: List of Storage operations supported by the Storage resource provider. - :vartype value: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.Operation] - :ivar next_link: The URL to get the next set of operations. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Operation]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Operation"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: List of Storage operations supported by the Storage resource provider. - :paramtype value: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.Operation] - :keyword next_link: The URL to get the next set of operations. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class Permissions(_serialization.Model): - """Permissions the identity has for keys, secrets, certificates and storage. - - :ivar keys: Permissions to keys. - :vartype keys: list[str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.KeyPermissions] - :ivar secrets: Permissions to secrets. - :vartype secrets: list[str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.SecretPermissions] - :ivar certificates: Permissions to certificates. - :vartype certificates: list[str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.CertificatePermissions] - :ivar storage: Permissions to storage accounts. - :vartype storage: list[str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.StoragePermissions] - """ - - _attribute_map = { - "keys": {"key": "keys", "type": "[str]"}, - "secrets": {"key": "secrets", "type": "[str]"}, - "certificates": {"key": "certificates", "type": "[str]"}, - "storage": {"key": "storage", "type": "[str]"}, - } - - def __init__( - self, - *, - keys: Optional[List[Union[str, "_models.KeyPermissions"]]] = None, - secrets: Optional[List[Union[str, "_models.SecretPermissions"]]] = None, - certificates: Optional[List[Union[str, "_models.CertificatePermissions"]]] = None, - storage: Optional[List[Union[str, "_models.StoragePermissions"]]] = None, - **kwargs: Any - ) -> None: - """ - :keyword keys: Permissions to keys. - :paramtype keys: list[str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.KeyPermissions] - :keyword secrets: Permissions to secrets. - :paramtype secrets: list[str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.SecretPermissions] - :keyword certificates: Permissions to certificates. - :paramtype certificates: list[str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.CertificatePermissions] - :keyword storage: Permissions to storage accounts. - :paramtype storage: list[str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.StoragePermissions] - """ - super().__init__(**kwargs) - self.keys = keys - self.secrets = secrets - self.certificates = certificates - self.storage = storage - - -class PrivateEndpoint(_serialization.Model): - """Private endpoint object properties. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Full identifier of the private endpoint resource. - :vartype id: str - """ - - _validation = { - "id": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.id = None - - -class Resource(_serialization.Model): - """Key Vault resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = None - self.tags = None - - -class PrivateEndpointConnection(Resource): - """Private endpoint connection resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar etag: Modified whenever there is a change in the state of private endpoint connection. - :vartype etag: str - :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpoint - :ivar private_link_service_connection_state: Approval state of the private link connection. - :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateLinkServiceConnectionState - :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values - are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnectionProvisioningState - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "etag": {"key": "etag", "type": "str"}, - "private_endpoint": {"key": "properties.privateEndpoint", "type": "PrivateEndpoint"}, - "private_link_service_connection_state": { - "key": "properties.privateLinkServiceConnectionState", - "type": "PrivateLinkServiceConnectionState", - }, - "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - etag: Optional[str] = None, - private_endpoint: Optional["_models.PrivateEndpoint"] = None, - private_link_service_connection_state: Optional["_models.PrivateLinkServiceConnectionState"] = None, - provisioning_state: Optional[Union[str, "_models.PrivateEndpointConnectionProvisioningState"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword etag: Modified whenever there is a change in the state of private endpoint connection. - :paramtype etag: str - :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpoint - :keyword private_link_service_connection_state: Approval state of the private link connection. - :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateLinkServiceConnectionState - :keyword provisioning_state: Provisioning state of the private endpoint connection. Known - values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnectionProvisioningState - """ - super().__init__(**kwargs) - self.etag = etag - self.private_endpoint = private_endpoint - self.private_link_service_connection_state = private_link_service_connection_state - self.provisioning_state = provisioning_state - - -class PrivateEndpointConnectionItem(_serialization.Model): - """Private endpoint connection item. - - :ivar id: Id of private endpoint connection. - :vartype id: str - :ivar etag: Modified whenever there is a change in the state of private endpoint connection. - :vartype etag: str - :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpoint - :ivar private_link_service_connection_state: Approval state of the private link connection. - :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateLinkServiceConnectionState - :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values - are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnectionProvisioningState - """ - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "etag": {"key": "etag", "type": "str"}, - "private_endpoint": {"key": "properties.privateEndpoint", "type": "PrivateEndpoint"}, - "private_link_service_connection_state": { - "key": "properties.privateLinkServiceConnectionState", - "type": "PrivateLinkServiceConnectionState", - }, - "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - id: Optional[str] = None, # pylint: disable=redefined-builtin - etag: Optional[str] = None, - private_endpoint: Optional["_models.PrivateEndpoint"] = None, - private_link_service_connection_state: Optional["_models.PrivateLinkServiceConnectionState"] = None, - provisioning_state: Optional[Union[str, "_models.PrivateEndpointConnectionProvisioningState"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword id: Id of private endpoint connection. - :paramtype id: str - :keyword etag: Modified whenever there is a change in the state of private endpoint connection. - :paramtype etag: str - :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpoint - :keyword private_link_service_connection_state: Approval state of the private link connection. - :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateLinkServiceConnectionState - :keyword provisioning_state: Provisioning state of the private endpoint connection. Known - values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnectionProvisioningState - """ - super().__init__(**kwargs) - self.id = id - self.etag = etag - self.private_endpoint = private_endpoint - self.private_link_service_connection_state = private_link_service_connection_state - self.provisioning_state = provisioning_state - - -class PrivateEndpointConnectionListResult(_serialization.Model): - """List of private endpoint connections. - - :ivar value: The list of private endpoint connections. - :vartype value: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection] - :ivar next_link: The URL to get the next set of private endpoint connections. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[PrivateEndpointConnection]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, - *, - value: Optional[List["_models.PrivateEndpointConnection"]] = None, - next_link: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword value: The list of private endpoint connections. - :paramtype value: - list[~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection] - :keyword next_link: The URL to get the next set of private endpoint connections. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class PrivateLinkResource(Resource): - """A private link resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar group_id: Group identifier of private link resource. - :vartype group_id: str - :ivar required_members: Required member names of private link resource. - :vartype required_members: list[str] - :ivar required_zone_names: Required DNS zone names of the the private link resource. - :vartype required_zone_names: list[str] - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - "group_id": {"readonly": True}, - "required_members": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "group_id": {"key": "properties.groupId", "type": "str"}, - "required_members": {"key": "properties.requiredMembers", "type": "[str]"}, - "required_zone_names": {"key": "properties.requiredZoneNames", "type": "[str]"}, - } - - def __init__(self, *, required_zone_names: Optional[List[str]] = None, **kwargs: Any) -> None: - """ - :keyword required_zone_names: Required DNS zone names of the the private link resource. - :paramtype required_zone_names: list[str] - """ - super().__init__(**kwargs) - self.group_id = None - self.required_members = None - self.required_zone_names = required_zone_names - - -class PrivateLinkResourceListResult(_serialization.Model): - """A list of private link resources. - - :ivar value: Array of private link resources. - :vartype value: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateLinkResource] - """ - - _attribute_map = { - "value": {"key": "value", "type": "[PrivateLinkResource]"}, - } - - def __init__(self, *, value: Optional[List["_models.PrivateLinkResource"]] = None, **kwargs: Any) -> None: - """ - :keyword value: Array of private link resources. - :paramtype value: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateLinkResource] - """ - super().__init__(**kwargs) - self.value = value - - -class PrivateLinkServiceConnectionState(_serialization.Model): - """An object that represents the approval state of the private link connection. - - :ivar status: Indicates whether the connection has been approved, rejected or removed by the - key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :vartype status: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointServiceConnectionStatus - :ivar description: The reason for approval or rejection. - :vartype description: str - :ivar actions_required: A message indicating if changes on the service provider require any - updates on the consumer. "None" - :vartype actions_required: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.ActionsRequired - """ - - _attribute_map = { - "status": {"key": "status", "type": "str"}, - "description": {"key": "description", "type": "str"}, - "actions_required": {"key": "actionsRequired", "type": "str"}, - } - - def __init__( - self, - *, - status: Optional[Union[str, "_models.PrivateEndpointServiceConnectionStatus"]] = None, - description: Optional[str] = None, - actions_required: Optional[Union[str, "_models.ActionsRequired"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword status: Indicates whether the connection has been approved, rejected or removed by the - key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :paramtype status: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointServiceConnectionStatus - :keyword description: The reason for approval or rejection. - :paramtype description: str - :keyword actions_required: A message indicating if changes on the service provider require any - updates on the consumer. "None" - :paramtype actions_required: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.ActionsRequired - """ - super().__init__(**kwargs) - self.status = status - self.description = description - self.actions_required = actions_required - - -class ResourceListResult(_serialization.Model): - """List of vault resources. - - :ivar value: The list of vault resources. - :vartype value: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.Resource] - :ivar next_link: The URL to get the next set of vault resources. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Resource]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Resource"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of vault resources. - :paramtype value: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.Resource] - :keyword next_link: The URL to get the next set of vault resources. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class ServiceSpecification(_serialization.Model): - """One property of operation, include log specifications. - - :ivar log_specifications: Log specifications of operation. - :vartype log_specifications: - list[~azure.mgmt.keyvault.v2021_04_01_preview.models.LogSpecification] - :ivar metric_specifications: Metric specifications of operation. - :vartype metric_specifications: - list[~azure.mgmt.keyvault.v2021_04_01_preview.models.MetricSpecification] - """ - - _attribute_map = { - "log_specifications": {"key": "logSpecifications", "type": "[LogSpecification]"}, - "metric_specifications": {"key": "metricSpecifications", "type": "[MetricSpecification]"}, - } - - def __init__( - self, - *, - log_specifications: Optional[List["_models.LogSpecification"]] = None, - metric_specifications: Optional[List["_models.MetricSpecification"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword log_specifications: Log specifications of operation. - :paramtype log_specifications: - list[~azure.mgmt.keyvault.v2021_04_01_preview.models.LogSpecification] - :keyword metric_specifications: Metric specifications of operation. - :paramtype metric_specifications: - list[~azure.mgmt.keyvault.v2021_04_01_preview.models.MetricSpecification] - """ - super().__init__(**kwargs) - self.log_specifications = log_specifications - self.metric_specifications = metric_specifications - - -class Sku(_serialization.Model): - """SKU details. - - All required parameters must be populated in order to send to server. - - :ivar family: SKU family name. "A" - :vartype family: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.SkuFamily - :ivar name: SKU name to specify whether the key vault is a standard vault or a premium vault. - Required. Known values are: "standard" and "premium". - :vartype name: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.SkuName - """ - - _validation = { - "family": {"required": True}, - "name": {"required": True}, - } - - _attribute_map = { - "family": {"key": "family", "type": "str"}, - "name": {"key": "name", "type": "str"}, - } - - def __init__( - self, *, family: Union[str, "_models.SkuFamily"] = "A", name: Union[str, "_models.SkuName"], **kwargs: Any - ) -> None: - """ - :keyword family: SKU family name. "A" - :paramtype family: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.SkuFamily - :keyword name: SKU name to specify whether the key vault is a standard vault or a premium - vault. Required. Known values are: "standard" and "premium". - :paramtype name: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.SkuName - """ - super().__init__(**kwargs) - self.family = family - self.name = name - - -class SystemData(_serialization.Model): - """Metadata pertaining to creation and last modification of the key vault resource. - - :ivar created_by: The identity that created the key vault resource. - :vartype created_by: str - :ivar created_by_type: The type of identity that created the key vault resource. Known values - are: "User", "Application", "ManagedIdentity", and "Key". - :vartype created_by_type: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.IdentityType - :ivar created_at: The timestamp of the key vault resource creation (UTC). - :vartype created_at: ~datetime.datetime - :ivar last_modified_by: The identity that last modified the key vault resource. - :vartype last_modified_by: str - :ivar last_modified_by_type: The type of identity that last modified the key vault resource. - Known values are: "User", "Application", "ManagedIdentity", and "Key". - :vartype last_modified_by_type: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.IdentityType - :ivar last_modified_at: The timestamp of the key vault resource last modification (UTC). - :vartype last_modified_at: ~datetime.datetime - """ - - _attribute_map = { - "created_by": {"key": "createdBy", "type": "str"}, - "created_by_type": {"key": "createdByType", "type": "str"}, - "created_at": {"key": "createdAt", "type": "iso-8601"}, - "last_modified_by": {"key": "lastModifiedBy", "type": "str"}, - "last_modified_by_type": {"key": "lastModifiedByType", "type": "str"}, - "last_modified_at": {"key": "lastModifiedAt", "type": "iso-8601"}, - } - - def __init__( - self, - *, - created_by: Optional[str] = None, - created_by_type: Optional[Union[str, "_models.IdentityType"]] = None, - created_at: Optional[datetime.datetime] = None, - last_modified_by: Optional[str] = None, - last_modified_by_type: Optional[Union[str, "_models.IdentityType"]] = None, - last_modified_at: Optional[datetime.datetime] = None, - **kwargs: Any - ) -> None: - """ - :keyword created_by: The identity that created the key vault resource. - :paramtype created_by: str - :keyword created_by_type: The type of identity that created the key vault resource. Known - values are: "User", "Application", "ManagedIdentity", and "Key". - :paramtype created_by_type: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.IdentityType - :keyword created_at: The timestamp of the key vault resource creation (UTC). - :paramtype created_at: ~datetime.datetime - :keyword last_modified_by: The identity that last modified the key vault resource. - :paramtype last_modified_by: str - :keyword last_modified_by_type: The type of identity that last modified the key vault resource. - Known values are: "User", "Application", "ManagedIdentity", and "Key". - :paramtype last_modified_by_type: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.IdentityType - :keyword last_modified_at: The timestamp of the key vault resource last modification (UTC). - :paramtype last_modified_at: ~datetime.datetime - """ - super().__init__(**kwargs) - self.created_by = created_by - self.created_by_type = created_by_type - self.created_at = created_at - self.last_modified_by = last_modified_by - self.last_modified_by_type = last_modified_by_type - self.last_modified_at = last_modified_at - - -class Vault(_serialization.Model): - """Resource information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar system_data: System metadata for the key vault. - :vartype system_data: ~azure.mgmt.keyvault.v2021_04_01_preview.models.SystemData - :ivar properties: Properties of the vault. Required. - :vartype properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "system_data": {"readonly": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "system_data": {"key": "systemData", "type": "SystemData"}, - "properties": {"key": "properties", "type": "VaultProperties"}, - } - - def __init__( - self, - *, - properties: "_models.VaultProperties", - location: Optional[str] = None, - tags: Optional[Dict[str, str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: Azure location of the key vault resource. - :paramtype location: str - :keyword tags: Tags assigned to the key vault resource. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the vault. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = location - self.tags = tags - self.system_data = None - self.properties = properties - - -class VaultAccessPolicyParameters(_serialization.Model): - """Parameters for updating the access policy in a vault. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar id: The resource id of the access policy. - :vartype id: str - :ivar name: The resource name of the access policy. - :vartype name: str - :ivar type: The resource name of the access policy. - :vartype type: str - :ivar location: The resource type of the access policy. - :vartype location: str - :ivar properties: Properties of the access policy. Required. - :vartype properties: - ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultAccessPolicyProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "properties": {"key": "properties", "type": "VaultAccessPolicyProperties"}, - } - - def __init__(self, *, properties: "_models.VaultAccessPolicyProperties", **kwargs: Any) -> None: - """ - :keyword properties: Properties of the access policy. Required. - :paramtype properties: - ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultAccessPolicyProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = None - self.properties = properties - - -class VaultAccessPolicyProperties(_serialization.Model): - """Properties of the vault access policy. - - All required parameters must be populated in order to send to server. - - :ivar access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. Required. - :vartype access_policies: - list[~azure.mgmt.keyvault.v2021_04_01_preview.models.AccessPolicyEntry] - """ - - _validation = { - "access_policies": {"required": True}, - } - - _attribute_map = { - "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, - } - - def __init__(self, *, access_policies: List["_models.AccessPolicyEntry"], **kwargs: Any) -> None: - """ - :keyword access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. Required. - :paramtype access_policies: - list[~azure.mgmt.keyvault.v2021_04_01_preview.models.AccessPolicyEntry] - """ - super().__init__(**kwargs) - self.access_policies = access_policies - - -class VaultCheckNameAvailabilityParameters(_serialization.Model): - """The parameters used to check the availability of the vault name. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar name: The vault name. Required. - :vartype name: str - :ivar type: The type of resource, Microsoft.KeyVault/vaults. Required. Default value is - "Microsoft.KeyVault/vaults". - :vartype type: str - """ - - _validation = { - "name": {"required": True}, - "type": {"required": True, "constant": True}, - } - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - } - - type = "Microsoft.KeyVault/vaults" - - def __init__(self, *, name: str, **kwargs: Any) -> None: - """ - :keyword name: The vault name. Required. - :paramtype name: str - """ - super().__init__(**kwargs) - self.name = name - - -class VaultCreateOrUpdateParameters(_serialization.Model): - """Parameters for creating or updating a vault. - - All required parameters must be populated in order to send to server. - - :ivar location: The supported Azure location where the key vault should be created. Required. - :vartype location: str - :ivar tags: The tags that will be assigned to the key vault. - :vartype tags: dict[str, str] - :ivar properties: Properties of the vault. Required. - :vartype properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultProperties - """ - - _validation = { - "location": {"required": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "VaultProperties"}, - } - - def __init__( - self, - *, - location: str, - properties: "_models.VaultProperties", - tags: Optional[Dict[str, str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the key vault should be created. - Required. - :paramtype location: str - :keyword tags: The tags that will be assigned to the key vault. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the vault. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultProperties - """ - super().__init__(**kwargs) - self.location = location - self.tags = tags - self.properties = properties - - -class VaultListResult(_serialization.Model): - """List of vaults. - - :ivar value: The list of vaults. - :vartype value: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault] - :ivar next_link: The URL to get the next set of vaults. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Vault]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Vault"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of vaults. - :paramtype value: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault] - :keyword next_link: The URL to get the next set of vaults. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class VaultPatchParameters(_serialization.Model): - """Parameters for creating or updating a vault. - - :ivar tags: The tags that will be assigned to the key vault. - :vartype tags: dict[str, str] - :ivar properties: Properties of the vault. - :vartype properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultPatchProperties - """ - - _attribute_map = { - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "VaultPatchProperties"}, - } - - def __init__( - self, - *, - tags: Optional[Dict[str, str]] = None, - properties: Optional["_models.VaultPatchProperties"] = None, - **kwargs: Any - ) -> None: - """ - :keyword tags: The tags that will be assigned to the key vault. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the vault. - :paramtype properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultPatchProperties - """ - super().__init__(**kwargs) - self.tags = tags - self.properties = properties - - -class VaultPatchProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Properties of the vault. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. - :vartype tenant_id: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2021_04_01_preview.models.Sku - :ivar access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. - :vartype access_policies: - list[~azure.mgmt.keyvault.v2021_04_01_preview.models.AccessPolicyEntry] - :ivar enabled_for_deployment: Property to specify whether Azure Virtual Machines are permitted - to retrieve certificates stored as secrets from the key vault. - :vartype enabled_for_deployment: bool - :ivar enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :vartype enabled_for_disk_encryption: bool - :ivar enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :vartype enabled_for_template_deployment: bool - :ivar enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. Once set to true, it cannot be reverted to false. - :vartype enable_soft_delete: bool - :ivar enable_rbac_authorization: Property that controls how data actions are authorized. When - true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored. When false, - the key vault will use the access policies specified in vault properties, and any policy stored - on Azure Resource Manager will be ignored. If null or not specified, the value of this property - will not change. - :vartype enable_rbac_authorization: bool - :ivar soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and <=90. - :vartype soft_delete_retention_in_days: int - :ivar create_mode: The vault's create mode to indicate whether the vault need to be recovered - or not. Known values are: "recover" and "default". - :vartype create_mode: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.CreateMode - :ivar enable_purge_protection: Property specifying whether protection against purge is enabled - for this vault. Setting this property to true activates protection against purge for this vault - and its content - only the Key Vault service may initiate a hard, irrecoverable deletion. The - setting is effective only if soft delete is also enabled. Enabling this functionality is - irreversible - that is, the property does not accept false as its value. - :vartype enable_purge_protection: bool - :ivar network_acls: A collection of rules governing the accessibility of the vault from - specific network locations. - :vartype network_acls: ~azure.mgmt.keyvault.v2021_04_01_preview.models.NetworkRuleSet - """ - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "sku": {"key": "sku", "type": "Sku"}, - "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, - "enabled_for_deployment": {"key": "enabledForDeployment", "type": "bool"}, - "enabled_for_disk_encryption": {"key": "enabledForDiskEncryption", "type": "bool"}, - "enabled_for_template_deployment": {"key": "enabledForTemplateDeployment", "type": "bool"}, - "enable_soft_delete": {"key": "enableSoftDelete", "type": "bool"}, - "enable_rbac_authorization": {"key": "enableRbacAuthorization", "type": "bool"}, - "soft_delete_retention_in_days": {"key": "softDeleteRetentionInDays", "type": "int"}, - "create_mode": {"key": "createMode", "type": "str"}, - "enable_purge_protection": {"key": "enablePurgeProtection", "type": "bool"}, - "network_acls": {"key": "networkAcls", "type": "NetworkRuleSet"}, - } - - def __init__( - self, - *, - tenant_id: Optional[str] = None, - sku: Optional["_models.Sku"] = None, - access_policies: Optional[List["_models.AccessPolicyEntry"]] = None, - enabled_for_deployment: Optional[bool] = None, - enabled_for_disk_encryption: Optional[bool] = None, - enabled_for_template_deployment: Optional[bool] = None, - enable_soft_delete: Optional[bool] = None, - enable_rbac_authorization: Optional[bool] = None, - soft_delete_retention_in_days: Optional[int] = None, - create_mode: Optional[Union[str, "_models.CreateMode"]] = None, - enable_purge_protection: Optional[bool] = None, - network_acls: Optional["_models.NetworkRuleSet"] = None, - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. - :paramtype tenant_id: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2021_04_01_preview.models.Sku - :keyword access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. - :paramtype access_policies: - list[~azure.mgmt.keyvault.v2021_04_01_preview.models.AccessPolicyEntry] - :keyword enabled_for_deployment: Property to specify whether Azure Virtual Machines are - permitted to retrieve certificates stored as secrets from the key vault. - :paramtype enabled_for_deployment: bool - :keyword enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :paramtype enabled_for_disk_encryption: bool - :keyword enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :paramtype enabled_for_template_deployment: bool - :keyword enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. Once set to true, it cannot be reverted to false. - :paramtype enable_soft_delete: bool - :keyword enable_rbac_authorization: Property that controls how data actions are authorized. - When true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored. When false, - the key vault will use the access policies specified in vault properties, and any policy stored - on Azure Resource Manager will be ignored. If null or not specified, the value of this property - will not change. - :paramtype enable_rbac_authorization: bool - :keyword soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and - <=90. - :paramtype soft_delete_retention_in_days: int - :keyword create_mode: The vault's create mode to indicate whether the vault need to be - recovered or not. Known values are: "recover" and "default". - :paramtype create_mode: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.CreateMode - :keyword enable_purge_protection: Property specifying whether protection against purge is - enabled for this vault. Setting this property to true activates protection against purge for - this vault and its content - only the Key Vault service may initiate a hard, irrecoverable - deletion. The setting is effective only if soft delete is also enabled. Enabling this - functionality is irreversible - that is, the property does not accept false as its value. - :paramtype enable_purge_protection: bool - :keyword network_acls: A collection of rules governing the accessibility of the vault from - specific network locations. - :paramtype network_acls: ~azure.mgmt.keyvault.v2021_04_01_preview.models.NetworkRuleSet - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.sku = sku - self.access_policies = access_policies - self.enabled_for_deployment = enabled_for_deployment - self.enabled_for_disk_encryption = enabled_for_disk_encryption - self.enabled_for_template_deployment = enabled_for_template_deployment - self.enable_soft_delete = enable_soft_delete - self.enable_rbac_authorization = enable_rbac_authorization - self.soft_delete_retention_in_days = soft_delete_retention_in_days - self.create_mode = create_mode - self.enable_purge_protection = enable_purge_protection - self.network_acls = network_acls - - -class VaultProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Properties of the vault. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :vartype tenant_id: str - :ivar sku: SKU details. Required. - :vartype sku: ~azure.mgmt.keyvault.v2021_04_01_preview.models.Sku - :ivar access_policies: An array of 0 to 1024 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. When - ``createMode`` is set to ``recover``\\ , access policies are not required. Otherwise, access - policies are required. - :vartype access_policies: - list[~azure.mgmt.keyvault.v2021_04_01_preview.models.AccessPolicyEntry] - :ivar vault_uri: The URI of the vault for performing operations on keys and secrets. - :vartype vault_uri: str - :ivar hsm_pool_resource_id: The resource id of HSM Pool. - :vartype hsm_pool_resource_id: str - :ivar enabled_for_deployment: Property to specify whether Azure Virtual Machines are permitted - to retrieve certificates stored as secrets from the key vault. - :vartype enabled_for_deployment: bool - :ivar enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :vartype enabled_for_disk_encryption: bool - :ivar enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :vartype enabled_for_template_deployment: bool - :ivar enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. If it's not set to any value(true or false) when creating new key - vault, it will be set to true by default. Once set to true, it cannot be reverted to false. - :vartype enable_soft_delete: bool - :ivar soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and <=90. - :vartype soft_delete_retention_in_days: int - :ivar enable_rbac_authorization: Property that controls how data actions are authorized. When - true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored. When false, - the key vault will use the access policies specified in vault properties, and any policy stored - on Azure Resource Manager will be ignored. If null or not specified, the vault is created with - the default value of false. Note that management actions are always authorized with RBAC. - :vartype enable_rbac_authorization: bool - :ivar create_mode: The vault's create mode to indicate whether the vault need to be recovered - or not. Known values are: "recover" and "default". - :vartype create_mode: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.CreateMode - :ivar enable_purge_protection: Property specifying whether protection against purge is enabled - for this vault. Setting this property to true activates protection against purge for this vault - and its content - only the Key Vault service may initiate a hard, irrecoverable deletion. The - setting is effective only if soft delete is also enabled. Enabling this functionality is - irreversible - that is, the property does not accept false as its value. - :vartype enable_purge_protection: bool - :ivar network_acls: Rules governing the accessibility of the key vault from specific network - locations. - :vartype network_acls: ~azure.mgmt.keyvault.v2021_04_01_preview.models.NetworkRuleSet - :ivar provisioning_state: Provisioning state of the vault. Known values are: "Succeeded" and - "RegisteringDns". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultProvisioningState - :ivar private_endpoint_connections: List of private endpoint connections associated with the - key vault. - :vartype private_endpoint_connections: - list[~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnectionItem] - """ - - _validation = { - "tenant_id": {"required": True}, - "sku": {"required": True}, - "hsm_pool_resource_id": {"readonly": True}, - "private_endpoint_connections": {"readonly": True}, - } - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "sku": {"key": "sku", "type": "Sku"}, - "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, - "vault_uri": {"key": "vaultUri", "type": "str"}, - "hsm_pool_resource_id": {"key": "hsmPoolResourceId", "type": "str"}, - "enabled_for_deployment": {"key": "enabledForDeployment", "type": "bool"}, - "enabled_for_disk_encryption": {"key": "enabledForDiskEncryption", "type": "bool"}, - "enabled_for_template_deployment": {"key": "enabledForTemplateDeployment", "type": "bool"}, - "enable_soft_delete": {"key": "enableSoftDelete", "type": "bool"}, - "soft_delete_retention_in_days": {"key": "softDeleteRetentionInDays", "type": "int"}, - "enable_rbac_authorization": {"key": "enableRbacAuthorization", "type": "bool"}, - "create_mode": {"key": "createMode", "type": "str"}, - "enable_purge_protection": {"key": "enablePurgeProtection", "type": "bool"}, - "network_acls": {"key": "networkAcls", "type": "NetworkRuleSet"}, - "provisioning_state": {"key": "provisioningState", "type": "str"}, - "private_endpoint_connections": { - "key": "privateEndpointConnections", - "type": "[PrivateEndpointConnectionItem]", - }, - } - - def __init__( - self, - *, - tenant_id: str, - sku: "_models.Sku", - access_policies: Optional[List["_models.AccessPolicyEntry"]] = None, - vault_uri: Optional[str] = None, - enabled_for_deployment: Optional[bool] = None, - enabled_for_disk_encryption: Optional[bool] = None, - enabled_for_template_deployment: Optional[bool] = None, - enable_soft_delete: bool = True, - soft_delete_retention_in_days: int = 90, - enable_rbac_authorization: bool = False, - create_mode: Optional[Union[str, "_models.CreateMode"]] = None, - enable_purge_protection: Optional[bool] = None, - network_acls: Optional["_models.NetworkRuleSet"] = None, - provisioning_state: Optional[Union[str, "_models.VaultProvisioningState"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :paramtype tenant_id: str - :keyword sku: SKU details. Required. - :paramtype sku: ~azure.mgmt.keyvault.v2021_04_01_preview.models.Sku - :keyword access_policies: An array of 0 to 1024 identities that have access to the key vault. - All identities in the array must use the same tenant ID as the key vault's tenant ID. When - ``createMode`` is set to ``recover``\\ , access policies are not required. Otherwise, access - policies are required. - :paramtype access_policies: - list[~azure.mgmt.keyvault.v2021_04_01_preview.models.AccessPolicyEntry] - :keyword vault_uri: The URI of the vault for performing operations on keys and secrets. - :paramtype vault_uri: str - :keyword enabled_for_deployment: Property to specify whether Azure Virtual Machines are - permitted to retrieve certificates stored as secrets from the key vault. - :paramtype enabled_for_deployment: bool - :keyword enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :paramtype enabled_for_disk_encryption: bool - :keyword enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :paramtype enabled_for_template_deployment: bool - :keyword enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. If it's not set to any value(true or false) when creating new key - vault, it will be set to true by default. Once set to true, it cannot be reverted to false. - :paramtype enable_soft_delete: bool - :keyword soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and - <=90. - :paramtype soft_delete_retention_in_days: int - :keyword enable_rbac_authorization: Property that controls how data actions are authorized. - When true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored. When false, - the key vault will use the access policies specified in vault properties, and any policy stored - on Azure Resource Manager will be ignored. If null or not specified, the vault is created with - the default value of false. Note that management actions are always authorized with RBAC. - :paramtype enable_rbac_authorization: bool - :keyword create_mode: The vault's create mode to indicate whether the vault need to be - recovered or not. Known values are: "recover" and "default". - :paramtype create_mode: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.CreateMode - :keyword enable_purge_protection: Property specifying whether protection against purge is - enabled for this vault. Setting this property to true activates protection against purge for - this vault and its content - only the Key Vault service may initiate a hard, irrecoverable - deletion. The setting is effective only if soft delete is also enabled. Enabling this - functionality is irreversible - that is, the property does not accept false as its value. - :paramtype enable_purge_protection: bool - :keyword network_acls: Rules governing the accessibility of the key vault from specific network - locations. - :paramtype network_acls: ~azure.mgmt.keyvault.v2021_04_01_preview.models.NetworkRuleSet - :keyword provisioning_state: Provisioning state of the vault. Known values are: "Succeeded" and - "RegisteringDns". - :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultProvisioningState - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.sku = sku - self.access_policies = access_policies - self.vault_uri = vault_uri - self.hsm_pool_resource_id = None - self.enabled_for_deployment = enabled_for_deployment - self.enabled_for_disk_encryption = enabled_for_disk_encryption - self.enabled_for_template_deployment = enabled_for_template_deployment - self.enable_soft_delete = enable_soft_delete - self.soft_delete_retention_in_days = soft_delete_retention_in_days - self.enable_rbac_authorization = enable_rbac_authorization - self.create_mode = create_mode - self.enable_purge_protection = enable_purge_protection - self.network_acls = network_acls - self.provisioning_state = provisioning_state - self.private_endpoint_connections = None - - -class VirtualNetworkRule(_serialization.Model): - """A rule governing the accessibility of a vault from a specific virtual network. - - All required parameters must be populated in order to send to server. - - :ivar id: Full resource id of a vnet subnet, such as - '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. - Required. - :vartype id: str - :ivar ignore_missing_vnet_service_endpoint: Property to specify whether NRP will ignore the - check if parent subnet has serviceEndpoints configured. - :vartype ignore_missing_vnet_service_endpoint: bool - """ - - _validation = { - "id": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "ignore_missing_vnet_service_endpoint": {"key": "ignoreMissingVnetServiceEndpoint", "type": "bool"}, - } - - def __init__( - self, - *, - id: str, # pylint: disable=redefined-builtin - ignore_missing_vnet_service_endpoint: Optional[bool] = None, - **kwargs: Any - ) -> None: - """ - :keyword id: Full resource id of a vnet subnet, such as - '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. # pylint: disable=line-too-long - Required. - :paramtype id: str - :keyword ignore_missing_vnet_service_endpoint: Property to specify whether NRP will ignore the - check if parent subnet has serviceEndpoints configured. - :paramtype ignore_missing_vnet_service_endpoint: bool - """ - super().__init__(**kwargs) - self.id = id - self.ignore_missing_vnet_service_endpoint = ignore_missing_vnet_service_endpoint diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/models/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/models/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/models/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/__init__.py deleted file mode 100644 index 1415b7f904e4..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/__init__.py +++ /dev/null @@ -1,31 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._vaults_operations import VaultsOperations -from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations -from ._private_link_resources_operations import PrivateLinkResourcesOperations -from ._managed_hsms_operations import ManagedHsmsOperations -from ._mhsm_private_endpoint_connections_operations import MHSMPrivateEndpointConnectionsOperations -from ._mhsm_private_link_resources_operations import MHSMPrivateLinkResourcesOperations -from ._operations import Operations - -from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "VaultsOperations", - "PrivateEndpointConnectionsOperations", - "PrivateLinkResourcesOperations", - "ManagedHsmsOperations", - "MHSMPrivateEndpointConnectionsOperations", - "MHSMPrivateLinkResourcesOperations", - "Operations", -] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_managed_hsms_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_managed_hsms_operations.py deleted file mode 100644 index 0cf1cb18fe3b..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_managed_hsms_operations.py +++ /dev/null @@ -1,1292 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_or_update_request( - resource_group_name: str, name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_request(resource_group_name: str, name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request(resource_group_name: str, name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request(resource_group_name: str, name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_resource_group_request( - resource_group_name: str, subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_subscription_request( - subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_deleted_request(subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedManagedHSMs") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_deleted_request(name: str, location: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "name": _SERIALIZER.url("name", name, "str"), - "location": _SERIALIZER.url("location", location, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_purge_deleted_request(name: str, location: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge", - ) # pylint: disable=line-too-long - path_format_arguments = { - "name": _SERIALIZER.url("name", name, "str"), - "location": _SERIALIZER.url("location", location, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -class ManagedHsmsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_04_01_preview.KeyVaultManagementClient`'s - :attr:`managed_hsms` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - def _create_or_update_initial( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "ManagedHsm") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def begin_create_or_update( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Is either a ManagedHsm - type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm or IO[bytes] - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._create_or_update_initial( - resource_group_name=resource_group_name, - name=name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.ManagedHsm].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.ManagedHsm]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - def _update_initial( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "ManagedHsm") - - _request = build_update_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @overload - def begin_update( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_update( - self, - resource_group_name: str, - name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def begin_update( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Is either a ManagedHsm type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm or IO[bytes] - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._update_initial( - resource_group_name=resource_group_name, - name=name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.ManagedHsm].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.ManagedHsm]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - def _delete_initial(self, resource_group_name: str, name: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_delete(self, resource_group_name: str, name: str, **kwargs: Any) -> LROPoller[None]: - """Deletes the specified managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: The name of the managed HSM Pool to delete. Required. - :type name: str - :return: An instance of LROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._delete_initial( - resource_group_name=resource_group_name, - name=name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def get(self, resource_group_name: str, name: str, **kwargs: Any) -> Optional[_models.ManagedHsm]: - """Gets the specified managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: The name of the managed HSM Pool. Required. - :type name: str - :return: ManagedHsm or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm or None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[Optional[_models.ManagedHsm]] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> Iterable["_models.ManagedHsm"]: - """The List operation gets information about the managed HSM Pools associated with the - subscription and within the specified resource group. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.ManagedHsm"]: - """The List operation gets information about the managed HSM Pools associated with the - subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedManagedHsm"]: - """The List operation gets information about the deleted managed HSMs associated with the - subscription. - - :return: An iterator like instance of either DeletedManagedHsm or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.DeletedManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.DeletedManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("DeletedManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def get_deleted(self, name: str, location: str, **kwargs: Any) -> _models.DeletedManagedHsm: - """Gets the specified deleted managed HSM. - - :param name: The name of the deleted managed HSM. Required. - :type name: str - :param location: The location of the deleted managed HSM. Required. - :type location: str - :return: DeletedManagedHsm or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.DeletedManagedHsm - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.DeletedManagedHsm] = kwargs.pop("cls", None) - - _request = build_get_deleted_request( - name=name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = self._deserialize("DeletedManagedHsm", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_purge_deleted_request( - name=name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_purge_deleted(self, name: str, location: str, **kwargs: Any) -> LROPoller[None]: - """Permanently deletes the specified managed HSM. - - :param name: The name of the soft-deleted managed HSM. Required. - :type name: str - :param location: The location of the soft-deleted managed HSM. Required. - :type location: str - :return: An instance of LROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._purge_deleted_initial( - name=name, - location=location, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_mhsm_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_mhsm_private_endpoint_connections_operations.py deleted file mode 100644 index d6db9b6b6955..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_mhsm_private_endpoint_connections_operations.py +++ /dev/null @@ -1,631 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_by_resource_request( - resource_group_name: str, name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request( - resource_group_name: str, name: str, private_endpoint_connection_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_put_request( - resource_group_name: str, name: str, private_endpoint_connection_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request( - resource_group_name: str, name: str, private_endpoint_connection_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -class MHSMPrivateEndpointConnectionsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_04_01_preview.KeyVaultManagementClient`'s - :attr:`mhsm_private_endpoint_connections` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list_by_resource( - self, resource_group_name: str, name: str, **kwargs: Any - ) -> Iterable["_models.MHSMPrivateEndpointConnection"]: - """The List operation gets information about the private endpoint connections associated with the - managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :return: An iterator like instance of either MHSMPrivateEndpointConnection or the result of - cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("MHSMPrivateEndpointConnectionsListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def get( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Gets the specified private endpoint connection associated with the managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: _models.MHSMPrivateEndpointConnection, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: Union[_models.MHSMPrivateEndpointConnection, IO[bytes]], - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Is either a - MHSMPrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection - or IO[bytes] - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _json = self._serialize.body(properties, "MHSMPrivateEndpointConnection") - - _request = build_put_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Azure-AsyncOperation"] = self._deserialize( - "str", response.headers.get("Azure-AsyncOperation") - ) - - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - def _delete_initial( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_delete( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> LROPoller[_models.MHSMPrivateEndpointConnection]: - """Deletes the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :return: An instance of LROPoller that returns either MHSMPrivateEndpointConnection or the - result of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._delete_initial( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.MHSMPrivateEndpointConnection].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.MHSMPrivateEndpointConnection]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_mhsm_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_mhsm_private_link_resources_operations.py deleted file mode 100644 index e1286da13709..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_mhsm_private_link_resources_operations.py +++ /dev/null @@ -1,148 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_by_mhsm_resource_request( - resource_group_name: str, name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateLinkResources", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class MHSMPrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_04_01_preview.KeyVaultManagementClient`'s - :attr:`mhsm_private_link_resources` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list_by_mhsm_resource( - self, resource_group_name: str, name: str, **kwargs: Any - ) -> _models.MHSMPrivateLinkResourceListResult: - """Gets the private link resources supported for the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :return: MHSMPrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateLinkResourceListResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.MHSMPrivateLinkResourceListResult] = kwargs.pop("cls", None) - - _request = build_list_by_mhsm_resource_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("MHSMPrivateLinkResourceListResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_operations.py deleted file mode 100644 index 36bc35ff04fb..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_operations.py +++ /dev/null @@ -1,154 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Iterable, Optional, Type, TypeVar -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_request(**kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/providers/Microsoft.KeyVault/operations") - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class Operations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_04_01_preview.KeyVaultManagementClient`'s - :attr:`operations` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: - """Lists all of the available Key Vault Rest API operations. - - :return: An iterator like instance of either Operation or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.Operation] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("OperationListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_patch.py deleted file mode 100644 index c87ec9bc212c..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_patch.py +++ /dev/null @@ -1,134 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -import sys -from typing import Any, List, Iterable, Optional, Type -import urllib.parse - -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.rest import HttpRequest -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ._vaults_operations import VaultsOperations as _VaultsOperations, ClsType, build_list_request -from .. import models as _models - -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports - -class VaultsOperations(_VaultsOperations): - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - -__all__: List[str] = ["VaultsOperations"] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_private_endpoint_connections_operations.py deleted file mode 100644 index f4a1afdfbc1e..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_private_endpoint_connections_operations.py +++ /dev/null @@ -1,637 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_get_request( - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_put_request( - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request( - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_resource_request( - resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class PrivateEndpointConnectionsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_04_01_preview.KeyVaultManagementClient`'s - :attr:`private_endpoint_connections` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def get( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Optional[_models.PrivateEndpointConnection]: - """Gets the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: PrivateEndpointConnection or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection or None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[Optional[_models.PrivateEndpointConnection]] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: _models.PrivateEndpointConnection, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: Union[_models.PrivateEndpointConnection, IO[bytes]], - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Is either a - PrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection or - IO[bytes] - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _json = self._serialize.body(properties, "PrivateEndpointConnection") - - _request = build_put_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Azure-AsyncOperation"] = self._deserialize( - "str", response.headers.get("Azure-AsyncOperation") - ) - - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - def _delete_initial( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_delete( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> LROPoller[_models.PrivateEndpointConnection]: - """Deletes the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: An instance of LROPoller that returns either PrivateEndpointConnection or the result - of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._delete_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.PrivateEndpointConnection].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.PrivateEndpointConnection]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @distributed_trace - def list_by_resource( - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> Iterable["_models.PrivateEndpointConnection"]: - """The List operation gets information about the private endpoint connections associated with the - vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :return: An iterator like instance of either PrivateEndpointConnection or the result of - cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.PrivateEndpointConnectionListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("PrivateEndpointConnectionListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_private_link_resources_operations.py deleted file mode 100644 index dbadbb38eaca..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_private_link_resources_operations.py +++ /dev/null @@ -1,147 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_by_vault_request( - resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class PrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_04_01_preview.KeyVaultManagementClient`'s - :attr:`private_link_resources` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list_by_vault( - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> _models.PrivateLinkResourceListResult: - """Gets the private link resources supported for the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :return: PrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateLinkResourceListResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.PrivateLinkResourceListResult] = kwargs.pop("cls", None) - - _request = build_list_by_vault_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_vaults_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_vaults_operations.py deleted file mode 100644 index 69532ee5fdc3..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/operations/_vaults_operations.py +++ /dev/null @@ -1,1614 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Literal, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_or_update_request( - resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_access_policy_request( - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "operationKind": _SERIALIZER.url("operation_kind", operation_kind, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_resource_group_request( - resource_group_name: str, subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_subscription_request( - subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_deleted_request(subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_deleted_request(vault_name: str, location: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "location": _SERIALIZER.url("location", location, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_purge_deleted_request(vault_name: str, location: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge", - ) # pylint: disable=line-too-long - path_format_arguments = { - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "location": _SERIALIZER.url("location", location, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_request(subscription_id: str, *, top: Optional[int] = None, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop("api_version", _params.pop("api-version", "2015-11-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resources") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["$filter"] = _SERIALIZER.query("filter", filter, "str") - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_check_name_availability_request(subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability" - ) - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -class VaultsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_04_01_preview.KeyVaultManagementClient`'s - :attr:`vaults` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - def _create_or_update_initial( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 201: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultCreateOrUpdateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> LROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Is either a - VaultCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultCreateOrUpdateParameters - or IO[bytes] - :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._create_or_update_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("Vault", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.Vault].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.Vault]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @overload - def update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultPatchParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultPatchParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultPatchParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Is either a VaultPatchParameters type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultPatchParameters or - IO[bytes] - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultPatchParameters") - - _request = build_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def delete( # pylint: disable=inconsistent-return-statements - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> None: - """Deletes the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault to delete. Required. - :type vault_name: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - @distributed_trace - def get(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> _models.Vault: - """Gets the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: _models.VaultAccessPolicyParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultAccessPolicyParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: Union[_models.VaultAccessPolicyParameters, IO[bytes]], - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or - ~azure.mgmt.keyvault.v2021_04_01_preview.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Is either a - VaultAccessPolicyParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultAccessPolicyParameters - or IO[bytes] - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.VaultAccessPolicyParameters] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") - - _request = build_update_access_policy_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - operation_kind=operation_kind, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> Iterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription and - within the specified resource group. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedVault"]: - """Gets information about the deleted vaults in a subscription. - - :return: An iterator like instance of either DeletedVault or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.DeletedVault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.DeletedVaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("DeletedVaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _models.DeletedVault: - """Gets the deleted Azure key vault. - - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param location: The location of the deleted vault. Required. - :type location: str - :return: DeletedVault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.DeletedVault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[_models.DeletedVault] = kwargs.pop("cls", None) - - _request = build_get_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("DeletedVault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_purge_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_purge_deleted(self, vault_name: str, location: str, **kwargs: Any) -> LROPoller[None]: - """Permanently deletes the specified vault. aka Purges the deleted Azure key vault. - - :param vault_name: The name of the soft-deleted vault. Required. - :type vault_name: str - :param location: The location of the soft-deleted vault. Required. - :type location: str - :return: An instance of LROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._purge_deleted_initial( - vault_name=vault_name, - location=location, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @overload - def check_name_availability( - self, - vault_name: _models.VaultCheckNameAvailabilityParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: - ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultCheckNameAvailabilityParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def check_name_availability( - self, vault_name: IO[bytes], *, content_type: str = "application/json", **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def check_name_availability( - self, vault_name: Union[_models.VaultCheckNameAvailabilityParameters, IO[bytes]], **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Is either a VaultCheckNameAvailabilityParameters type - or a IO[bytes] type. Required. - :type vault_name: - ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultCheckNameAvailabilityParameters or - IO[bytes] - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-04-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.CheckNameAvailabilityResult] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(vault_name, (IOBase, bytes)): - _content = vault_name - else: - _json = self._serialize.body(vault_name, "VaultCheckNameAvailabilityParameters") - - _request = build_check_name_availability_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/py.typed b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/py.typed deleted file mode 100644 index e5aff4f83af8..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/py.typed +++ /dev/null @@ -1 +0,0 @@ -# Marker file for PEP 561. \ No newline at end of file diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/__init__.py deleted file mode 100644 index 6bb4b7c63a45..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/__init__.py +++ /dev/null @@ -1,26 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._key_vault_management_client import KeyVaultManagementClient -from ._version import VERSION - -__version__ = VERSION - -try: - from ._patch import __all__ as _patch_all - from ._patch import * # pylint: disable=unused-wildcard-import -except ImportError: - _patch_all = [] -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "KeyVaultManagementClient", -] -__all__.extend([p for p in _patch_all if p not in __all__]) - -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/_configuration.py deleted file mode 100644 index ea186512723f..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/_configuration.py +++ /dev/null @@ -1,66 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from typing import Any, TYPE_CHECKING - -from azure.core.pipeline import policies -from azure.mgmt.core.policies import ARMChallengeAuthenticationPolicy, ARMHttpLoggingPolicy - -from ._version import VERSION - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials import TokenCredential - - -class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long - """Configuration for KeyVaultManagementClient. - - Note that all parameters used to create this instance are saved as instance - attributes. - - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials.TokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :keyword api_version: Api Version. Default value is "2021-06-01-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str - """ - - def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None: - api_version: str = kwargs.pop("api_version", "2021-06-01-preview") - - if credential is None: - raise ValueError("Parameter 'credential' must not be None.") - if subscription_id is None: - raise ValueError("Parameter 'subscription_id' must not be None.") - - self.credential = credential - self.subscription_id = subscription_id - self.api_version = api_version - self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) - kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) - self.polling_interval = kwargs.get("polling_interval", 30) - self._configure(**kwargs) - - def _configure(self, **kwargs: Any) -> None: - 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.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**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) - self.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs) - self.authentication_policy = kwargs.get("authentication_policy") - if self.credential and not self.authentication_policy: - self.authentication_policy = ARMChallengeAuthenticationPolicy( - self.credential, *self.credential_scopes, **kwargs - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/_key_vault_management_client.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/_key_vault_management_client.py deleted file mode 100644 index 63989610714b..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/_key_vault_management_client.py +++ /dev/null @@ -1,168 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from copy import deepcopy -from typing import Any, TYPE_CHECKING -from typing_extensions import Self - -from azure.core.pipeline import policies -from azure.core.rest import HttpRequest, HttpResponse -from azure.mgmt.core import ARMPipelineClient -from azure.mgmt.core.policies import ARMAutoResourceProviderRegistrationPolicy - -from . import models as _models -from .._serialization import Deserializer, Serializer -from ._configuration import KeyVaultManagementClientConfiguration -from .operations import ( - KeysOperations, - MHSMPrivateEndpointConnectionsOperations, - MHSMPrivateLinkResourcesOperations, - ManagedHsmsOperations, - Operations, - PrivateEndpointConnectionsOperations, - PrivateLinkResourcesOperations, - SecretsOperations, - VaultsOperations, -) - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials import TokenCredential - - -class KeyVaultManagementClient: # pylint: disable=client-accepts-api-version-keyword,too-many-instance-attributes - """The Azure management API provides a RESTful set of web services that interact with Azure Key - Vault. - - :ivar keys: KeysOperations operations - :vartype keys: azure.mgmt.keyvault.v2021_06_01_preview.operations.KeysOperations - :ivar vaults: VaultsOperations operations - :vartype vaults: azure.mgmt.keyvault.v2021_06_01_preview.operations.VaultsOperations - :ivar private_endpoint_connections: PrivateEndpointConnectionsOperations operations - :vartype private_endpoint_connections: - azure.mgmt.keyvault.v2021_06_01_preview.operations.PrivateEndpointConnectionsOperations - :ivar private_link_resources: PrivateLinkResourcesOperations operations - :vartype private_link_resources: - azure.mgmt.keyvault.v2021_06_01_preview.operations.PrivateLinkResourcesOperations - :ivar managed_hsms: ManagedHsmsOperations operations - :vartype managed_hsms: azure.mgmt.keyvault.v2021_06_01_preview.operations.ManagedHsmsOperations - :ivar mhsm_private_endpoint_connections: MHSMPrivateEndpointConnectionsOperations operations - :vartype mhsm_private_endpoint_connections: - azure.mgmt.keyvault.v2021_06_01_preview.operations.MHSMPrivateEndpointConnectionsOperations - :ivar mhsm_private_link_resources: MHSMPrivateLinkResourcesOperations operations - :vartype mhsm_private_link_resources: - azure.mgmt.keyvault.v2021_06_01_preview.operations.MHSMPrivateLinkResourcesOperations - :ivar operations: Operations operations - :vartype operations: azure.mgmt.keyvault.v2021_06_01_preview.operations.Operations - :ivar secrets: SecretsOperations operations - :vartype secrets: azure.mgmt.keyvault.v2021_06_01_preview.operations.SecretsOperations - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials.TokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :param base_url: Service URL. Default value is "https://management.azure.com". - :type base_url: str - :keyword api_version: Api Version. Default value is "2021-06-01-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. - """ - - def __init__( - self, - credential: "TokenCredential", - subscription_id: str, - base_url: str = "https://management.azure.com", - **kwargs: Any - ) -> None: - self._config = KeyVaultManagementClientConfiguration( - credential=credential, subscription_id=subscription_id, **kwargs - ) - _policies = kwargs.pop("policies", None) - if _policies is None: - _policies = [ - policies.RequestIdPolicy(**kwargs), - self._config.headers_policy, - self._config.user_agent_policy, - self._config.proxy_policy, - policies.ContentDecodePolicy(**kwargs), - ARMAutoResourceProviderRegistrationPolicy(), - self._config.redirect_policy, - self._config.retry_policy, - self._config.authentication_policy, - self._config.custom_hook_policy, - self._config.logging_policy, - policies.DistributedTracingPolicy(**kwargs), - policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, - self._config.http_logging_policy, - ] - self._client: ARMPipelineClient = ARMPipelineClient(base_url=base_url, policies=_policies, **kwargs) - - client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} - self._serialize = Serializer(client_models) - self._deserialize = Deserializer(client_models) - self._serialize.client_side_validation = False - self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize, "2021-06-01-preview") - self.vaults = VaultsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-06-01-preview" - ) - self.private_endpoint_connections = PrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-06-01-preview" - ) - self.private_link_resources = PrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-06-01-preview" - ) - self.managed_hsms = ManagedHsmsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-06-01-preview" - ) - self.mhsm_private_endpoint_connections = MHSMPrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-06-01-preview" - ) - self.mhsm_private_link_resources = MHSMPrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-06-01-preview" - ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize, "2021-06-01-preview" - ) - self.secrets = SecretsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-06-01-preview" - ) - - def _send_request(self, request: HttpRequest, *, stream: bool = False, **kwargs: Any) -> HttpResponse: - """Runs the network request through the client's chained policies. - - >>> from azure.core.rest import HttpRequest - >>> request = HttpRequest("GET", "https://www.example.org/") - - >>> response = client._send_request(request) - - - For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request - - :param request: The network request you want to make. Required. - :type request: ~azure.core.rest.HttpRequest - :keyword bool stream: Whether the response payload will be streamed. Defaults to False. - :return: The response of your network call. Does not do error handling on your response. - :rtype: ~azure.core.rest.HttpResponse - """ - - request_copy = deepcopy(request) - request_copy.url = self._client.format_url(request_copy.url) - return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore - - def close(self) -> None: - self._client.close() - - def __enter__(self) -> Self: - self._client.__enter__() - return self - - def __exit__(self, *exc_details: Any) -> None: - self._client.__exit__(*exc_details) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/_metadata.json b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/_metadata.json deleted file mode 100644 index 53aa88352fa9..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/_metadata.json +++ /dev/null @@ -1,118 +0,0 @@ -{ - "chosen_version": "2021-06-01-preview", - "total_api_version_list": ["2021-06-01-preview"], - "client": { - "name": "KeyVaultManagementClient", - "filename": "_key_vault_management_client", - "description": "The Azure management API provides a RESTful set of web services that interact with Azure Key Vault.", - "host_value": "\"https://management.azure.com\"", - "parameterized_host_template": null, - "azure_arm": true, - "has_public_lro_operations": true, - "client_side_validation": false, - "sync_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"sdkcore\": {\"azure.mgmt.core\": [\"ARMPipelineClient\"], \"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"ARMAutoResourceProviderRegistrationPolicy\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \".._serialization\": [\"Deserializer\", \"Serializer\"]}, \"stdlib\": {\"typing_extensions\": [\"Self\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}}", - "async_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"sdkcore\": {\"azure.mgmt.core\": [\"AsyncARMPipelineClient\"], \"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"AsyncARMAutoResourceProviderRegistrationPolicy\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \"..._serialization\": [\"Deserializer\", \"Serializer\"]}, \"stdlib\": {\"typing_extensions\": [\"Self\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"]}}}" - }, - "global_parameters": { - "sync": { - "credential": { - "signature": "credential: \"TokenCredential\",", - "description": "Credential needed for the client to connect to Azure. Required.", - "docstring_type": "~azure.core.credentials.TokenCredential", - "required": true, - "method_location": "positional" - }, - "subscription_id": { - "signature": "subscription_id: str,", - "description": "Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. Required.", - "docstring_type": "str", - "required": true, - "method_location": "positional" - } - }, - "async": { - "credential": { - "signature": "credential: \"AsyncTokenCredential\",", - "description": "Credential needed for the client to connect to Azure. Required.", - "docstring_type": "~azure.core.credentials_async.AsyncTokenCredential", - "required": true - }, - "subscription_id": { - "signature": "subscription_id: str,", - "description": "Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. Required.", - "docstring_type": "str", - "required": true - } - }, - "constant": { - }, - "call": "credential, subscription_id", - "service_client_specific": { - "sync": { - "api_version": { - "signature": "api_version: Optional[str]=None,", - "description": "API version to use if no profile is provided, or if missing in profile.", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "base_url": { - "signature": "base_url: str = \"https://management.azure.com\",", - "description": "Service URL", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "profile": { - "signature": "profile: KnownProfiles=KnownProfiles.default,", - "description": "A profile definition, from KnownProfiles to dict.", - "docstring_type": "azure.profiles.KnownProfiles", - "required": false, - "method_location": "positional" - } - }, - "async": { - "api_version": { - "signature": "api_version: Optional[str] = None,", - "description": "API version to use if no profile is provided, or if missing in profile.", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "base_url": { - "signature": "base_url: str = \"https://management.azure.com\",", - "description": "Service URL", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "profile": { - "signature": "profile: KnownProfiles = KnownProfiles.default,", - "description": "A profile definition, from KnownProfiles to dict.", - "docstring_type": "azure.profiles.KnownProfiles", - "required": false, - "method_location": "positional" - } - } - } - }, - "config": { - "credential": true, - "credential_scopes": ["https://management.azure.com/.default"], - "credential_call_sync": "ARMChallengeAuthenticationPolicy(self.credential, *self.credential_scopes, **kwargs)", - "credential_call_async": "AsyncARMChallengeAuthenticationPolicy(self.credential, *self.credential_scopes, **kwargs)", - "sync_imports": "{\"regular\": {\"sdkcore\": {\"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"ARMChallengeAuthenticationPolicy\", \"ARMHttpLoggingPolicy\"]}, \"local\": {\"._version\": [\"VERSION\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}}", - "async_imports": "{\"regular\": {\"sdkcore\": {\"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"ARMHttpLoggingPolicy\", \"AsyncARMChallengeAuthenticationPolicy\"]}, \"local\": {\".._version\": [\"VERSION\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"]}}}" - }, - "operation_groups": { - "keys": "KeysOperations", - "vaults": "VaultsOperations", - "private_endpoint_connections": "PrivateEndpointConnectionsOperations", - "private_link_resources": "PrivateLinkResourcesOperations", - "managed_hsms": "ManagedHsmsOperations", - "mhsm_private_endpoint_connections": "MHSMPrivateEndpointConnectionsOperations", - "mhsm_private_link_resources": "MHSMPrivateLinkResourcesOperations", - "operations": "Operations", - "secrets": "SecretsOperations" - } -} diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/_version.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/_version.py deleted file mode 100644 index 3b99a1418535..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/_version.py +++ /dev/null @@ -1,9 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -VERSION = "10.3.1" diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/__init__.py deleted file mode 100644 index 6ba0c5a05353..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/__init__.py +++ /dev/null @@ -1,23 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._key_vault_management_client import KeyVaultManagementClient - -try: - from ._patch import __all__ as _patch_all - from ._patch import * # pylint: disable=unused-wildcard-import -except ImportError: - _patch_all = [] -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "KeyVaultManagementClient", -] -__all__.extend([p for p in _patch_all if p not in __all__]) - -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/_configuration.py deleted file mode 100644 index 10df2b59a14f..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/_configuration.py +++ /dev/null @@ -1,66 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from typing import Any, TYPE_CHECKING - -from azure.core.pipeline import policies -from azure.mgmt.core.policies import ARMHttpLoggingPolicy, AsyncARMChallengeAuthenticationPolicy - -from .._version import VERSION - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials_async import AsyncTokenCredential - - -class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long - """Configuration for KeyVaultManagementClient. - - Note that all parameters used to create this instance are saved as instance - attributes. - - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials_async.AsyncTokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :keyword api_version: Api Version. Default value is "2021-06-01-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str - """ - - def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None: - api_version: str = kwargs.pop("api_version", "2021-06-01-preview") - - if credential is None: - raise ValueError("Parameter 'credential' must not be None.") - if subscription_id is None: - raise ValueError("Parameter 'subscription_id' must not be None.") - - self.credential = credential - self.subscription_id = subscription_id - self.api_version = api_version - self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) - kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) - self.polling_interval = kwargs.get("polling_interval", 30) - self._configure(**kwargs) - - def _configure(self, **kwargs: Any) -> None: - 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.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**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) - self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) - self.authentication_policy = kwargs.get("authentication_policy") - if self.credential and not self.authentication_policy: - self.authentication_policy = AsyncARMChallengeAuthenticationPolicy( - self.credential, *self.credential_scopes, **kwargs - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/_key_vault_management_client.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/_key_vault_management_client.py deleted file mode 100644 index 587c5b7270e4..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/_key_vault_management_client.py +++ /dev/null @@ -1,171 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from copy import deepcopy -from typing import Any, Awaitable, TYPE_CHECKING -from typing_extensions import Self - -from azure.core.pipeline import policies -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.mgmt.core import AsyncARMPipelineClient -from azure.mgmt.core.policies import AsyncARMAutoResourceProviderRegistrationPolicy - -from .. import models as _models -from ..._serialization import Deserializer, Serializer -from ._configuration import KeyVaultManagementClientConfiguration -from .operations import ( - KeysOperations, - MHSMPrivateEndpointConnectionsOperations, - MHSMPrivateLinkResourcesOperations, - ManagedHsmsOperations, - Operations, - PrivateEndpointConnectionsOperations, - PrivateLinkResourcesOperations, - SecretsOperations, - VaultsOperations, -) - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials_async import AsyncTokenCredential - - -class KeyVaultManagementClient: # pylint: disable=client-accepts-api-version-keyword,too-many-instance-attributes - """The Azure management API provides a RESTful set of web services that interact with Azure Key - Vault. - - :ivar keys: KeysOperations operations - :vartype keys: azure.mgmt.keyvault.v2021_06_01_preview.aio.operations.KeysOperations - :ivar vaults: VaultsOperations operations - :vartype vaults: azure.mgmt.keyvault.v2021_06_01_preview.aio.operations.VaultsOperations - :ivar private_endpoint_connections: PrivateEndpointConnectionsOperations operations - :vartype private_endpoint_connections: - azure.mgmt.keyvault.v2021_06_01_preview.aio.operations.PrivateEndpointConnectionsOperations - :ivar private_link_resources: PrivateLinkResourcesOperations operations - :vartype private_link_resources: - azure.mgmt.keyvault.v2021_06_01_preview.aio.operations.PrivateLinkResourcesOperations - :ivar managed_hsms: ManagedHsmsOperations operations - :vartype managed_hsms: - azure.mgmt.keyvault.v2021_06_01_preview.aio.operations.ManagedHsmsOperations - :ivar mhsm_private_endpoint_connections: MHSMPrivateEndpointConnectionsOperations operations - :vartype mhsm_private_endpoint_connections: - azure.mgmt.keyvault.v2021_06_01_preview.aio.operations.MHSMPrivateEndpointConnectionsOperations - :ivar mhsm_private_link_resources: MHSMPrivateLinkResourcesOperations operations - :vartype mhsm_private_link_resources: - azure.mgmt.keyvault.v2021_06_01_preview.aio.operations.MHSMPrivateLinkResourcesOperations - :ivar operations: Operations operations - :vartype operations: azure.mgmt.keyvault.v2021_06_01_preview.aio.operations.Operations - :ivar secrets: SecretsOperations operations - :vartype secrets: azure.mgmt.keyvault.v2021_06_01_preview.aio.operations.SecretsOperations - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials_async.AsyncTokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :param base_url: Service URL. Default value is "https://management.azure.com". - :type base_url: str - :keyword api_version: Api Version. Default value is "2021-06-01-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. - """ - - def __init__( - self, - credential: "AsyncTokenCredential", - subscription_id: str, - base_url: str = "https://management.azure.com", - **kwargs: Any - ) -> None: - self._config = KeyVaultManagementClientConfiguration( - credential=credential, subscription_id=subscription_id, **kwargs - ) - _policies = kwargs.pop("policies", None) - if _policies is None: - _policies = [ - policies.RequestIdPolicy(**kwargs), - self._config.headers_policy, - self._config.user_agent_policy, - self._config.proxy_policy, - policies.ContentDecodePolicy(**kwargs), - AsyncARMAutoResourceProviderRegistrationPolicy(), - self._config.redirect_policy, - self._config.retry_policy, - self._config.authentication_policy, - self._config.custom_hook_policy, - self._config.logging_policy, - policies.DistributedTracingPolicy(**kwargs), - policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, - self._config.http_logging_policy, - ] - self._client: AsyncARMPipelineClient = AsyncARMPipelineClient(base_url=base_url, policies=_policies, **kwargs) - - client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} - self._serialize = Serializer(client_models) - self._deserialize = Deserializer(client_models) - self._serialize.client_side_validation = False - self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize, "2021-06-01-preview") - self.vaults = VaultsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-06-01-preview" - ) - self.private_endpoint_connections = PrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-06-01-preview" - ) - self.private_link_resources = PrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-06-01-preview" - ) - self.managed_hsms = ManagedHsmsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-06-01-preview" - ) - self.mhsm_private_endpoint_connections = MHSMPrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-06-01-preview" - ) - self.mhsm_private_link_resources = MHSMPrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-06-01-preview" - ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize, "2021-06-01-preview" - ) - self.secrets = SecretsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-06-01-preview" - ) - - def _send_request( - self, request: HttpRequest, *, stream: bool = False, **kwargs: Any - ) -> Awaitable[AsyncHttpResponse]: - """Runs the network request through the client's chained policies. - - >>> from azure.core.rest import HttpRequest - >>> request = HttpRequest("GET", "https://www.example.org/") - - >>> response = await client._send_request(request) - - - For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request - - :param request: The network request you want to make. Required. - :type request: ~azure.core.rest.HttpRequest - :keyword bool stream: Whether the response payload will be streamed. Defaults to False. - :return: The response of your network call. Does not do error handling on your response. - :rtype: ~azure.core.rest.AsyncHttpResponse - """ - - request_copy = deepcopy(request) - request_copy.url = self._client.format_url(request_copy.url) - return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore - - async def close(self) -> None: - await self._client.close() - - async def __aenter__(self) -> Self: - await self._client.__aenter__() - return self - - async def __aexit__(self, *exc_details: Any) -> None: - await self._client.__aexit__(*exc_details) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/__init__.py deleted file mode 100644 index 224be3f73e55..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/__init__.py +++ /dev/null @@ -1,35 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._keys_operations import KeysOperations -from ._vaults_operations import VaultsOperations -from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations -from ._private_link_resources_operations import PrivateLinkResourcesOperations -from ._managed_hsms_operations import ManagedHsmsOperations -from ._mhsm_private_endpoint_connections_operations import MHSMPrivateEndpointConnectionsOperations -from ._mhsm_private_link_resources_operations import MHSMPrivateLinkResourcesOperations -from ._operations import Operations -from ._secrets_operations import SecretsOperations - -from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "KeysOperations", - "VaultsOperations", - "PrivateEndpointConnectionsOperations", - "PrivateLinkResourcesOperations", - "ManagedHsmsOperations", - "MHSMPrivateEndpointConnectionsOperations", - "MHSMPrivateLinkResourcesOperations", - "Operations", - "SecretsOperations", -] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_keys_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_keys_operations.py deleted file mode 100644 index be7f039bf6f2..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_keys_operations.py +++ /dev/null @@ -1,514 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, Type, TypeVar, Union, overload -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._keys_operations import ( - build_create_if_not_exist_request, - build_get_request, - build_get_version_request, - build_list_request, - build_list_versions_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class KeysOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_06_01_preview.aio.KeyVaultManagementClient`'s - :attr:`keys` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @overload - async def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: _models.KeyCreateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyCreateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: Union[_models.KeyCreateParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Is either a - KeyCreateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyCreateParameters or - IO[bytes] - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "KeyCreateParameters") - - _request = build_create_if_not_exist_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def get(self, resource_group_name: str, vault_name: str, key_name: str, **kwargs: Any) -> _models.Key: - """Gets the current version of the specified key from the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key to be retrieved. Required. - :type vault_name: str - :param key_name: The name of the key to be retrieved. Required. - :type key_name: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> AsyncIterable["_models.Key"]: - """Lists the keys in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the keys to be retrieved. Required. - :type vault_name: str - :return: An iterator like instance of either Key or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.Key] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("KeyListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace_async - async def get_version( - self, resource_group_name: str, vault_name: str, key_name: str, key_version: str, **kwargs: Any - ) -> _models.Key: - """Gets the specified version of the specified key in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key version to be retrieved. - Required. - :type vault_name: str - :param key_name: The name of the key version to be retrieved. Required. - :type key_name: str - :param key_version: The version of the key to be retrieved. Required. - :type key_version: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - _request = build_get_version_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - key_version=key_version, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_versions( - self, resource_group_name: str, vault_name: str, key_name: str, **kwargs: Any - ) -> AsyncIterable["_models.Key"]: - """Lists the versions of the specified key in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key versions to be retrieved. - Required. - :type vault_name: str - :param key_name: The name of the key versions to be retrieved. Required. - :type key_name: str - :return: An iterator like instance of either Key or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.Key] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_versions_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("KeyListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_managed_hsms_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_managed_hsms_operations.py deleted file mode 100644 index 35e378469b86..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_managed_hsms_operations.py +++ /dev/null @@ -1,1040 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._managed_hsms_operations import ( - build_create_or_update_request, - build_delete_request, - build_get_deleted_request, - build_get_request, - build_list_by_resource_group_request, - build_list_by_subscription_request, - build_list_deleted_request, - build_purge_deleted_request, - build_update_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class ManagedHsmsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_06_01_preview.aio.KeyVaultManagementClient`'s - :attr:`managed_hsms` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - async def _create_or_update_initial( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "ManagedHsm") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def begin_create_or_update( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Is either a ManagedHsm - type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm or IO[bytes] - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._create_or_update_initial( - resource_group_name=resource_group_name, - name=name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.ManagedHsm].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.ManagedHsm]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - async def _update_initial( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "ManagedHsm") - - _request = build_update_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @overload - async def begin_update( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_update( - self, - resource_group_name: str, - name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def begin_update( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Is either a ManagedHsm type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm or IO[bytes] - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._update_initial( - resource_group_name=resource_group_name, - name=name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.ManagedHsm].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.ManagedHsm]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - async def _delete_initial(self, resource_group_name: str, name: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_delete(self, resource_group_name: str, name: str, **kwargs: Any) -> AsyncLROPoller[None]: - """Deletes the specified managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: The name of the managed HSM Pool to delete. Required. - :type name: str - :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._delete_initial( - resource_group_name=resource_group_name, - name=name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace_async - async def get(self, resource_group_name: str, name: str, **kwargs: Any) -> Optional[_models.ManagedHsm]: - """Gets the specified managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: The name of the managed HSM Pool. Required. - :type name: str - :return: ManagedHsm or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm or None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[Optional[_models.ManagedHsm]] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable["_models.ManagedHsm"]: - """The List operation gets information about the managed HSM Pools associated with the - subscription and within the specified resource group. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.ManagedHsm"]: - """The List operation gets information about the managed HSM Pools associated with the - subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedManagedHsm"]: - """The List operation gets information about the deleted managed HSMs associated with the - subscription. - - :return: An iterator like instance of either DeletedManagedHsm or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletedManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.DeletedManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("DeletedManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace_async - async def get_deleted(self, name: str, location: str, **kwargs: Any) -> _models.DeletedManagedHsm: - """Gets the specified deleted managed HSM. - - :param name: The name of the deleted managed HSM. Required. - :type name: str - :param location: The location of the deleted managed HSM. Required. - :type location: str - :return: DeletedManagedHsm or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletedManagedHsm - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.DeletedManagedHsm] = kwargs.pop("cls", None) - - _request = build_get_deleted_request( - name=name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = self._deserialize("DeletedManagedHsm", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - async def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_purge_deleted_request( - name=name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_purge_deleted(self, name: str, location: str, **kwargs: Any) -> AsyncLROPoller[None]: - """Permanently deletes the specified managed HSM. - - :param name: The name of the soft-deleted managed HSM. Required. - :type name: str - :param location: The location of the soft-deleted managed HSM. Required. - :type location: str - :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._purge_deleted_initial( - name=name, - location=location, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_mhsm_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_mhsm_private_endpoint_connections_operations.py deleted file mode 100644 index fca8423fb71b..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_mhsm_private_endpoint_connections_operations.py +++ /dev/null @@ -1,498 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._mhsm_private_endpoint_connections_operations import ( - build_delete_request, - build_get_request, - build_list_by_resource_request, - build_put_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class MHSMPrivateEndpointConnectionsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_06_01_preview.aio.KeyVaultManagementClient`'s - :attr:`mhsm_private_endpoint_connections` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list_by_resource( - self, resource_group_name: str, name: str, **kwargs: Any - ) -> AsyncIterable["_models.MHSMPrivateEndpointConnection"]: - """The List operation gets information about the private endpoint connections associated with the - managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :return: An iterator like instance of either MHSMPrivateEndpointConnection or the result of - cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("MHSMPrivateEndpointConnectionsListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace_async - async def get( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Gets the specified private endpoint connection associated with the managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: _models.MHSMPrivateEndpointConnection, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: Union[_models.MHSMPrivateEndpointConnection, IO[bytes]], - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Is either a - MHSMPrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection - or IO[bytes] - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _json = self._serialize.body(properties, "MHSMPrivateEndpointConnection") - - _request = build_put_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Azure-AsyncOperation"] = self._deserialize( - "str", response.headers.get("Azure-AsyncOperation") - ) - - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - async def _delete_initial( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_delete( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> AsyncLROPoller[_models.MHSMPrivateEndpointConnection]: - """Deletes the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :return: An instance of AsyncLROPoller that returns either MHSMPrivateEndpointConnection or the - result of cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._delete_initial( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.MHSMPrivateEndpointConnection].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.MHSMPrivateEndpointConnection]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_mhsm_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_mhsm_private_link_resources_operations.py deleted file mode 100644 index 4fd7c27adf26..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_mhsm_private_link_resources_operations.py +++ /dev/null @@ -1,114 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._mhsm_private_link_resources_operations import build_list_by_mhsm_resource_request - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class MHSMPrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_06_01_preview.aio.KeyVaultManagementClient`'s - :attr:`mhsm_private_link_resources` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace_async - async def list_by_mhsm_resource( - self, resource_group_name: str, name: str, **kwargs: Any - ) -> _models.MHSMPrivateLinkResourceListResult: - """Gets the private link resources supported for the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :return: MHSMPrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateLinkResourceListResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.MHSMPrivateLinkResourceListResult] = kwargs.pop("cls", None) - - _request = build_list_by_mhsm_resource_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("MHSMPrivateLinkResourceListResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_operations.py deleted file mode 100644 index 4adfcd68c39c..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_operations.py +++ /dev/null @@ -1,133 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, AsyncIterable, Callable, Dict, Optional, Type, TypeVar -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._operations import build_list_request - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class Operations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_06_01_preview.aio.KeyVaultManagementClient`'s - :attr:`operations` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: - """Lists all of the available Key Vault Rest API operations. - - :return: An iterator like instance of either Operation or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.Operation] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("OperationListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_patch.py deleted file mode 100644 index 9b4f32f151b7..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_patch.py +++ /dev/null @@ -1,136 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -import sys -from typing import AsyncIterable, Any, Optional, List, Type -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ._vaults_operations import VaultsOperations as _VaultsOperations, ClsType -from ...operations._vaults_operations import build_list_request - -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports - -class VaultsOperations(_VaultsOperations): - - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - -__all__: List[str] = ["VaultsOperations"] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_private_endpoint_connections_operations.py deleted file mode 100644 index ebf0660e1551..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_private_endpoint_connections_operations.py +++ /dev/null @@ -1,492 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._private_endpoint_connections_operations import ( - build_delete_request, - build_get_request, - build_list_by_resource_request, - build_put_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class PrivateEndpointConnectionsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_06_01_preview.aio.KeyVaultManagementClient`'s - :attr:`private_endpoint_connections` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace_async - async def get( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Optional[_models.PrivateEndpointConnection]: - """Gets the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: PrivateEndpointConnection or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection or None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[Optional[_models.PrivateEndpointConnection]] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: _models.PrivateEndpointConnection, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: Union[_models.PrivateEndpointConnection, IO[bytes]], - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Is either a - PrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection or - IO[bytes] - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _json = self._serialize.body(properties, "PrivateEndpointConnection") - - _request = build_put_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Azure-AsyncOperation"] = self._deserialize( - "str", response.headers.get("Azure-AsyncOperation") - ) - - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - async def _delete_initial( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_delete( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> AsyncLROPoller[_models.PrivateEndpointConnection]: - """Deletes the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: An instance of AsyncLROPoller that returns either PrivateEndpointConnection or the - result of cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._delete_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.PrivateEndpointConnection].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.PrivateEndpointConnection]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @distributed_trace - def list_by_resource( - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> AsyncIterable["_models.PrivateEndpointConnection"]: - """The List operation gets information about the private endpoint connections associated with the - vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :return: An iterator like instance of either PrivateEndpointConnection or the result of - cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.PrivateEndpointConnectionListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("PrivateEndpointConnectionListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_private_link_resources_operations.py deleted file mode 100644 index 76b60c6aa528..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_private_link_resources_operations.py +++ /dev/null @@ -1,113 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._private_link_resources_operations import build_list_by_vault_request - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class PrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_06_01_preview.aio.KeyVaultManagementClient`'s - :attr:`private_link_resources` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace_async - async def list_by_vault( - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> _models.PrivateLinkResourceListResult: - """Gets the private link resources supported for the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :return: PrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateLinkResourceListResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.PrivateLinkResourceListResult] = kwargs.pop("cls", None) - - _request = build_list_by_vault_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_secrets_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_secrets_operations.py deleted file mode 100644 index 613e5496793b..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_secrets_operations.py +++ /dev/null @@ -1,523 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, Type, TypeVar, Union, overload -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._secrets_operations import ( - build_create_or_update_request, - build_get_request, - build_list_request, - build_update_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class SecretsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_06_01_preview.aio.KeyVaultManagementClient`'s - :attr:`secrets` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @overload - async def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: _models.SecretCreateOrUpdateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Required. - :type parameters: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretCreateOrUpdateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: Union[_models.SecretCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Is either a - SecretCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretCreateOrUpdateParameters or IO[bytes] - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "SecretCreateOrUpdateParameters") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: _models.SecretPatchParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretPatchParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: Union[_models.SecretPatchParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Is either a SecretPatchParameters type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretPatchParameters or - IO[bytes] - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "SecretPatchParameters") - - _request = build_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def get(self, resource_group_name: str, vault_name: str, secret_name: str, **kwargs: Any) -> _models.Secret: - """Gets the specified secret. NOTE: This API is intended for internal use in ARM deployments. - Users should use the data-plane REST service for interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param secret_name: The name of the secret. Required. - :type secret_name: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list( - self, resource_group_name: str, vault_name: str, top: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable["_models.Secret"]: - """The List operation gets information about the secrets in a vault. NOTE: This API is intended - for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Secret or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.SecretListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("SecretListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_vaults_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_vaults_operations.py deleted file mode 100644 index 9519d34e55f7..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/aio/operations/_vaults_operations.py +++ /dev/null @@ -1,1281 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import ( - Any, - AsyncIterable, - AsyncIterator, - Callable, - Dict, - IO, - Literal, - Optional, - Type, - TypeVar, - Union, - cast, - overload, -) -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._vaults_operations import ( - build_check_name_availability_request, - build_create_or_update_request, - build_delete_request, - build_get_deleted_request, - build_get_request, - build_list_by_resource_group_request, - build_list_by_subscription_request, - build_list_deleted_request, - build_list_request, - build_purge_deleted_request, - build_update_access_policy_request, - build_update_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class VaultsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_06_01_preview.aio.KeyVaultManagementClient`'s - :attr:`vaults` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - async def _create_or_update_initial( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 201: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultCreateOrUpdateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> AsyncLROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Is either a - VaultCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultCreateOrUpdateParameters - or IO[bytes] - :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._create_or_update_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("Vault", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.Vault].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.Vault]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @overload - async def update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultPatchParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultPatchParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultPatchParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Is either a VaultPatchParameters type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultPatchParameters or - IO[bytes] - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultPatchParameters") - - _request = build_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def delete( # pylint: disable=inconsistent-return-statements - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> None: - """Deletes the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault to delete. Required. - :type vault_name: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - @distributed_trace_async - async def get(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> _models.Vault: - """Gets the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: _models.VaultAccessPolicyParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultAccessPolicyParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: Union[_models.VaultAccessPolicyParameters, IO[bytes]], - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Is either a - VaultAccessPolicyParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultAccessPolicyParameters - or IO[bytes] - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.VaultAccessPolicyParameters] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") - - _request = build_update_access_policy_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - operation_kind=operation_kind, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription and - within the specified resource group. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedVault"]: - """Gets information about the deleted vaults in a subscription. - - :return: An iterator like instance of either DeletedVault or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletedVault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.DeletedVaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("DeletedVaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace_async - async def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _models.DeletedVault: - """Gets the deleted Azure key vault. - - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param location: The location of the deleted vault. Required. - :type location: str - :return: DeletedVault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletedVault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.DeletedVault] = kwargs.pop("cls", None) - - _request = build_get_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("DeletedVault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - async def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_purge_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_purge_deleted(self, vault_name: str, location: str, **kwargs: Any) -> AsyncLROPoller[None]: - """Permanently deletes the specified vault. aka Purges the deleted Azure key vault. - - :param vault_name: The name of the soft-deleted vault. Required. - :type vault_name: str - :param location: The location of the soft-deleted vault. Required. - :type location: str - :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._purge_deleted_initial( - vault_name=vault_name, - location=location, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @overload - async def check_name_availability( - self, - vault_name: _models.VaultCheckNameAvailabilityParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultCheckNameAvailabilityParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def check_name_availability( - self, vault_name: IO[bytes], *, content_type: str = "application/json", **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def check_name_availability( - self, vault_name: Union[_models.VaultCheckNameAvailabilityParameters, IO[bytes]], **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Is either a VaultCheckNameAvailabilityParameters type - or a IO[bytes] type. Required. - :type vault_name: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultCheckNameAvailabilityParameters or - IO[bytes] - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.CheckNameAvailabilityResult] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(vault_name, (IOBase, bytes)): - _content = vault_name - else: - _json = self._serialize.body(vault_name, "VaultCheckNameAvailabilityParameters") - - _request = build_check_name_availability_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/models/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/models/__init__.py deleted file mode 100644 index f495cfaa2d9e..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/models/__init__.py +++ /dev/null @@ -1,219 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._models_py3 import AccessPolicyEntry -from ._models_py3 import Action -from ._models_py3 import Attributes -from ._models_py3 import CheckNameAvailabilityResult -from ._models_py3 import CloudErrorBody -from ._models_py3 import DeletedManagedHsm -from ._models_py3 import DeletedManagedHsmListResult -from ._models_py3 import DeletedManagedHsmProperties -from ._models_py3 import DeletedVault -from ._models_py3 import DeletedVaultListResult -from ._models_py3 import DeletedVaultProperties -from ._models_py3 import DimensionProperties -from ._models_py3 import Error -from ._models_py3 import IPRule -from ._models_py3 import Key -from ._models_py3 import KeyAttributes -from ._models_py3 import KeyCreateParameters -from ._models_py3 import KeyListResult -from ._models_py3 import KeyProperties -from ._models_py3 import KeyReleasePolicy -from ._models_py3 import KeyRotationPolicyAttributes -from ._models_py3 import LifetimeAction -from ._models_py3 import LogSpecification -from ._models_py3 import MHSMIPRule -from ._models_py3 import MHSMNetworkRuleSet -from ._models_py3 import MHSMPrivateEndpoint -from ._models_py3 import MHSMPrivateEndpointConnection -from ._models_py3 import MHSMPrivateEndpointConnectionItem -from ._models_py3 import MHSMPrivateEndpointConnectionsListResult -from ._models_py3 import MHSMPrivateLinkResource -from ._models_py3 import MHSMPrivateLinkResourceListResult -from ._models_py3 import MHSMPrivateLinkServiceConnectionState -from ._models_py3 import MHSMVirtualNetworkRule -from ._models_py3 import ManagedHsm -from ._models_py3 import ManagedHsmError -from ._models_py3 import ManagedHsmListResult -from ._models_py3 import ManagedHsmProperties -from ._models_py3 import ManagedHsmResource -from ._models_py3 import ManagedHsmSku -from ._models_py3 import MetricSpecification -from ._models_py3 import NetworkRuleSet -from ._models_py3 import Operation -from ._models_py3 import OperationDisplay -from ._models_py3 import OperationListResult -from ._models_py3 import Permissions -from ._models_py3 import PrivateEndpoint -from ._models_py3 import PrivateEndpointConnection -from ._models_py3 import PrivateEndpointConnectionItem -from ._models_py3 import PrivateEndpointConnectionListResult -from ._models_py3 import PrivateLinkResource -from ._models_py3 import PrivateLinkResourceListResult -from ._models_py3 import PrivateLinkServiceConnectionState -from ._models_py3 import Resource -from ._models_py3 import ResourceListResult -from ._models_py3 import RotationPolicy -from ._models_py3 import Secret -from ._models_py3 import SecretAttributes -from ._models_py3 import SecretCreateOrUpdateParameters -from ._models_py3 import SecretListResult -from ._models_py3 import SecretPatchParameters -from ._models_py3 import SecretPatchProperties -from ._models_py3 import SecretProperties -from ._models_py3 import ServiceSpecification -from ._models_py3 import Sku -from ._models_py3 import SystemData -from ._models_py3 import Trigger -from ._models_py3 import Vault -from ._models_py3 import VaultAccessPolicyParameters -from ._models_py3 import VaultAccessPolicyProperties -from ._models_py3 import VaultCheckNameAvailabilityParameters -from ._models_py3 import VaultCreateOrUpdateParameters -from ._models_py3 import VaultListResult -from ._models_py3 import VaultPatchParameters -from ._models_py3 import VaultPatchProperties -from ._models_py3 import VaultProperties -from ._models_py3 import VirtualNetworkRule - -from ._key_vault_management_client_enums import AccessPolicyUpdateKind -from ._key_vault_management_client_enums import ActionsRequired -from ._key_vault_management_client_enums import CertificatePermissions -from ._key_vault_management_client_enums import CreateMode -from ._key_vault_management_client_enums import DeletionRecoveryLevel -from ._key_vault_management_client_enums import IdentityType -from ._key_vault_management_client_enums import JsonWebKeyCurveName -from ._key_vault_management_client_enums import JsonWebKeyOperation -from ._key_vault_management_client_enums import JsonWebKeyType -from ._key_vault_management_client_enums import KeyPermissions -from ._key_vault_management_client_enums import KeyRotationPolicyActionType -from ._key_vault_management_client_enums import ManagedHsmSkuFamily -from ._key_vault_management_client_enums import ManagedHsmSkuName -from ._key_vault_management_client_enums import NetworkRuleAction -from ._key_vault_management_client_enums import NetworkRuleBypassOptions -from ._key_vault_management_client_enums import PrivateEndpointConnectionProvisioningState -from ._key_vault_management_client_enums import PrivateEndpointServiceConnectionStatus -from ._key_vault_management_client_enums import ProvisioningState -from ._key_vault_management_client_enums import PublicNetworkAccess -from ._key_vault_management_client_enums import Reason -from ._key_vault_management_client_enums import SecretPermissions -from ._key_vault_management_client_enums import SkuFamily -from ._key_vault_management_client_enums import SkuName -from ._key_vault_management_client_enums import StoragePermissions -from ._key_vault_management_client_enums import VaultProvisioningState -from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "AccessPolicyEntry", - "Action", - "Attributes", - "CheckNameAvailabilityResult", - "CloudErrorBody", - "DeletedManagedHsm", - "DeletedManagedHsmListResult", - "DeletedManagedHsmProperties", - "DeletedVault", - "DeletedVaultListResult", - "DeletedVaultProperties", - "DimensionProperties", - "Error", - "IPRule", - "Key", - "KeyAttributes", - "KeyCreateParameters", - "KeyListResult", - "KeyProperties", - "KeyReleasePolicy", - "KeyRotationPolicyAttributes", - "LifetimeAction", - "LogSpecification", - "MHSMIPRule", - "MHSMNetworkRuleSet", - "MHSMPrivateEndpoint", - "MHSMPrivateEndpointConnection", - "MHSMPrivateEndpointConnectionItem", - "MHSMPrivateEndpointConnectionsListResult", - "MHSMPrivateLinkResource", - "MHSMPrivateLinkResourceListResult", - "MHSMPrivateLinkServiceConnectionState", - "MHSMVirtualNetworkRule", - "ManagedHsm", - "ManagedHsmError", - "ManagedHsmListResult", - "ManagedHsmProperties", - "ManagedHsmResource", - "ManagedHsmSku", - "MetricSpecification", - "NetworkRuleSet", - "Operation", - "OperationDisplay", - "OperationListResult", - "Permissions", - "PrivateEndpoint", - "PrivateEndpointConnection", - "PrivateEndpointConnectionItem", - "PrivateEndpointConnectionListResult", - "PrivateLinkResource", - "PrivateLinkResourceListResult", - "PrivateLinkServiceConnectionState", - "Resource", - "ResourceListResult", - "RotationPolicy", - "Secret", - "SecretAttributes", - "SecretCreateOrUpdateParameters", - "SecretListResult", - "SecretPatchParameters", - "SecretPatchProperties", - "SecretProperties", - "ServiceSpecification", - "Sku", - "SystemData", - "Trigger", - "Vault", - "VaultAccessPolicyParameters", - "VaultAccessPolicyProperties", - "VaultCheckNameAvailabilityParameters", - "VaultCreateOrUpdateParameters", - "VaultListResult", - "VaultPatchParameters", - "VaultPatchProperties", - "VaultProperties", - "VirtualNetworkRule", - "AccessPolicyUpdateKind", - "ActionsRequired", - "CertificatePermissions", - "CreateMode", - "DeletionRecoveryLevel", - "IdentityType", - "JsonWebKeyCurveName", - "JsonWebKeyOperation", - "JsonWebKeyType", - "KeyPermissions", - "KeyRotationPolicyActionType", - "ManagedHsmSkuFamily", - "ManagedHsmSkuName", - "NetworkRuleAction", - "NetworkRuleBypassOptions", - "PrivateEndpointConnectionProvisioningState", - "PrivateEndpointServiceConnectionStatus", - "ProvisioningState", - "PublicNetworkAccess", - "Reason", - "SecretPermissions", - "SkuFamily", - "SkuName", - "StoragePermissions", - "VaultProvisioningState", -] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/models/_key_vault_management_client_enums.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/models/_key_vault_management_client_enums.py deleted file mode 100644 index 3859029aaf7e..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/models/_key_vault_management_client_enums.py +++ /dev/null @@ -1,288 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from enum import Enum -from azure.core import CaseInsensitiveEnumMeta - - -class AccessPolicyUpdateKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """AccessPolicyUpdateKind.""" - - ADD = "add" - REPLACE = "replace" - REMOVE = "remove" - - -class ActionsRequired(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """A message indicating if changes on the service provider require any updates on the consumer.""" - - NONE = "None" - - -class CertificatePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """CertificatePermissions.""" - - ALL = "all" - GET = "get" - LIST = "list" - DELETE = "delete" - CREATE = "create" - IMPORT = "import" - UPDATE = "update" - MANAGECONTACTS = "managecontacts" - GETISSUERS = "getissuers" - LISTISSUERS = "listissuers" - SETISSUERS = "setissuers" - DELETEISSUERS = "deleteissuers" - MANAGEISSUERS = "manageissuers" - RECOVER = "recover" - PURGE = "purge" - BACKUP = "backup" - RESTORE = "restore" - IMPORT_ENUM = "import" - - -class CreateMode(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The vault's create mode to indicate whether the vault need to be recovered or not.""" - - RECOVER = "recover" - DEFAULT = "default" - - -class DeletionRecoveryLevel(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The deletion recovery level currently in effect for the object. If it contains 'Purgeable', - then the object can be permanently deleted by a privileged user; otherwise, only the system can - purge the object at the end of the retention interval. - """ - - PURGEABLE = "Purgeable" - RECOVERABLE_PURGEABLE = "Recoverable+Purgeable" - RECOVERABLE = "Recoverable" - RECOVERABLE_PROTECTED_SUBSCRIPTION = "Recoverable+ProtectedSubscription" - - -class IdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of identity.""" - - USER = "User" - APPLICATION = "Application" - MANAGED_IDENTITY = "ManagedIdentity" - KEY = "Key" - - -class JsonWebKeyCurveName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The elliptic curve name. For valid values, see JsonWebKeyCurveName.""" - - P256 = "P-256" - P384 = "P-384" - P521 = "P-521" - P256_K = "P-256K" - - -class JsonWebKeyOperation(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The permitted JSON web key operations of the key. For more information, see - JsonWebKeyOperation. - """ - - ENCRYPT = "encrypt" - DECRYPT = "decrypt" - SIGN = "sign" - VERIFY = "verify" - WRAP_KEY = "wrapKey" - UNWRAP_KEY = "unwrapKey" - IMPORT = "import" - RELEASE = "release" - IMPORT_ENUM = "import" - - -class JsonWebKeyType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of the key. For valid values, see JsonWebKeyType.""" - - EC = "EC" - EC_HSM = "EC-HSM" - RSA = "RSA" - RSA_HSM = "RSA-HSM" - - -class KeyPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """KeyPermissions.""" - - ALL = "all" - ENCRYPT = "encrypt" - DECRYPT = "decrypt" - WRAP_KEY = "wrapKey" - UNWRAP_KEY = "unwrapKey" - SIGN = "sign" - VERIFY = "verify" - GET = "get" - LIST = "list" - CREATE = "create" - UPDATE = "update" - IMPORT = "import" - DELETE = "delete" - BACKUP = "backup" - RESTORE = "restore" - RECOVER = "recover" - PURGE = "purge" - ROTATE = "rotate" - GETROTATIONPOLICY = "getrotationpolicy" - SETROTATIONPOLICY = "setrotationpolicy" - RELEASE = "release" - IMPORT_ENUM = "import" - - -class KeyRotationPolicyActionType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of the action. The value should be compared case-insensitively.""" - - ROTATE = "Rotate" - """Rotate the key based on the key policy.""" - NOTIFY = "Notify" - """Trigger Event Grid events. Defaults to 30 days before expiry. Key Vault only.""" - - -class ManagedHsmSkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU Family of the managed HSM Pool.""" - - B = "B" - - -class ManagedHsmSkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU of the managed HSM Pool.""" - - STANDARD_B1 = "Standard_B1" - CUSTOM_B32 = "Custom_B32" - CUSTOM_B6 = "Custom_B6" - - -class NetworkRuleAction(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The default action when no rule from ipRules and from virtualNetworkRules match. This is only - used after the bypass property has been evaluated. - """ - - ALLOW = "Allow" - DENY = "Deny" - - -class NetworkRuleBypassOptions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Tells what traffic can bypass network rules. This can be 'AzureServices' or 'None'. If not - specified the default is 'AzureServices'. - """ - - AZURE_SERVICES = "AzureServices" - NONE = "None" - - -class PrivateEndpointConnectionProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The current provisioning state.""" - - SUCCEEDED = "Succeeded" - CREATING = "Creating" - UPDATING = "Updating" - DELETING = "Deleting" - FAILED = "Failed" - DISCONNECTED = "Disconnected" - - -class PrivateEndpointServiceConnectionStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The private endpoint connection status.""" - - PENDING = "Pending" - APPROVED = "Approved" - REJECTED = "Rejected" - DISCONNECTED = "Disconnected" - - -class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Provisioning state.""" - - SUCCEEDED = "Succeeded" - """The managed HSM Pool has been full provisioned.""" - PROVISIONING = "Provisioning" - """The managed HSM Pool is currently being provisioned.""" - FAILED = "Failed" - """Provisioning of the managed HSM Pool has failed.""" - UPDATING = "Updating" - """The managed HSM Pool is currently being updated.""" - DELETING = "Deleting" - """The managed HSM Pool is currently being deleted.""" - ACTIVATED = "Activated" - """The managed HSM pool is ready for normal use.""" - SECURITY_DOMAIN_RESTORE = "SecurityDomainRestore" - """The managed HSM pool is waiting for a security domain restore action.""" - RESTORING = "Restoring" - """The managed HSM pool is being restored from full HSM backup.""" - - -class PublicNetworkAccess(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Control permission to the managed HSM from public networks.""" - - ENABLED = "Enabled" - DISABLED = "Disabled" - - -class Reason(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The reason that a vault name could not be used. The Reason element is only returned if - NameAvailable is false. - """ - - ACCOUNT_NAME_INVALID = "AccountNameInvalid" - ALREADY_EXISTS = "AlreadyExists" - - -class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SecretPermissions.""" - - ALL = "all" - GET = "get" - LIST = "list" - SET = "set" - DELETE = "delete" - BACKUP = "backup" - RESTORE = "restore" - RECOVER = "recover" - PURGE = "purge" - - -class SkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU family name.""" - - A = "A" - - -class SkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU name to specify whether the key vault is a standard vault or a premium vault.""" - - STANDARD = "standard" - PREMIUM = "premium" - - -class StoragePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """StoragePermissions.""" - - ALL = "all" - GET = "get" - LIST = "list" - DELETE = "delete" - SET = "set" - UPDATE = "update" - REGENERATEKEY = "regeneratekey" - RECOVER = "recover" - PURGE = "purge" - BACKUP = "backup" - RESTORE = "restore" - SETSAS = "setsas" - LISTSAS = "listsas" - GETSAS = "getsas" - DELETESAS = "deletesas" - - -class VaultProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Provisioning state of the vault.""" - - SUCCEEDED = "Succeeded" - REGISTERING_DNS = "RegisteringDns" diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/models/_models_py3.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/models/_models_py3.py deleted file mode 100644 index 3f0b919e83bd..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/models/_models_py3.py +++ /dev/null @@ -1,3751 +0,0 @@ -# coding=utf-8 -# pylint: disable=too-many-lines -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -import datetime -from typing import Any, Dict, List, Optional, TYPE_CHECKING, Union - -from ... import _serialization - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from .. import models as _models - - -class AccessPolicyEntry(_serialization.Model): - """An identity that have access to the key vault. All identities in the array must use the same - tenant ID as the key vault's tenant ID. - - All required parameters must be populated in order to send to server. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :vartype tenant_id: str - :ivar object_id: The object ID of a user, service principal or security group in the Azure - Active Directory tenant for the vault. The object ID must be unique for the list of access - policies. Required. - :vartype object_id: str - :ivar application_id: Application ID of the client making request on behalf of a principal. - :vartype application_id: str - :ivar permissions: Permissions the identity has for keys, secrets and certificates. Required. - :vartype permissions: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Permissions - """ - - _validation = { - "tenant_id": {"required": True}, - "object_id": {"required": True}, - "permissions": {"required": True}, - } - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "object_id": {"key": "objectId", "type": "str"}, - "application_id": {"key": "applicationId", "type": "str"}, - "permissions": {"key": "permissions", "type": "Permissions"}, - } - - def __init__( - self, - *, - tenant_id: str, - object_id: str, - permissions: "_models.Permissions", - application_id: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :paramtype tenant_id: str - :keyword object_id: The object ID of a user, service principal or security group in the Azure - Active Directory tenant for the vault. The object ID must be unique for the list of access - policies. Required. - :paramtype object_id: str - :keyword application_id: Application ID of the client making request on behalf of a principal. - :paramtype application_id: str - :keyword permissions: Permissions the identity has for keys, secrets and certificates. - Required. - :paramtype permissions: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Permissions - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.object_id = object_id - self.application_id = application_id - self.permissions = permissions - - -class Action(_serialization.Model): - """Action. - - :ivar type: The type of the action. The value should be compared case-insensitively. Known - values are: "Rotate" and "Notify". - :vartype type: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyRotationPolicyActionType - """ - - _attribute_map = { - "type": {"key": "type", "type": "str"}, - } - - def __init__( - self, *, type: Optional[Union[str, "_models.KeyRotationPolicyActionType"]] = None, **kwargs: Any - ) -> None: - """ - :keyword type: The type of the action. The value should be compared case-insensitively. Known - values are: "Rotate" and "Notify". - :paramtype type: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyRotationPolicyActionType - """ - super().__init__(**kwargs) - self.type = type - - -class Attributes(_serialization.Model): - """The object attributes managed by the KeyVault service. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar enabled: Determines whether the object is enabled. - :vartype enabled: bool - :ivar not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :vartype not_before: ~datetime.datetime - :ivar expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :vartype expires: ~datetime.datetime - :ivar created: Creation time in seconds since 1970-01-01T00:00:00Z. - :vartype created: ~datetime.datetime - :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: ~datetime.datetime - """ - - _validation = { - "created": {"readonly": True}, - "updated": {"readonly": True}, - } - - _attribute_map = { - "enabled": {"key": "enabled", "type": "bool"}, - "not_before": {"key": "nbf", "type": "unix-time"}, - "expires": {"key": "exp", "type": "unix-time"}, - "created": {"key": "created", "type": "unix-time"}, - "updated": {"key": "updated", "type": "unix-time"}, - } - - def __init__( - self, - *, - enabled: Optional[bool] = None, - not_before: Optional[datetime.datetime] = None, - expires: Optional[datetime.datetime] = None, - **kwargs: Any - ) -> None: - """ - :keyword enabled: Determines whether the object is enabled. - :paramtype enabled: bool - :keyword not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :paramtype not_before: ~datetime.datetime - :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :paramtype expires: ~datetime.datetime - """ - super().__init__(**kwargs) - self.enabled = enabled - self.not_before = not_before - self.expires = expires - self.created = None - self.updated = None - - -class CheckNameAvailabilityResult(_serialization.Model): - """The CheckNameAvailability operation response. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar name_available: A boolean value that indicates whether the name is available for you to - use. If true, the name is available. If false, the name has already been taken or is invalid - and cannot be used. - :vartype name_available: bool - :ivar reason: The reason that a vault name could not be used. The Reason element is only - returned if NameAvailable is false. Known values are: "AccountNameInvalid" and "AlreadyExists". - :vartype reason: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.Reason - :ivar message: An error message explaining the Reason value in more detail. - :vartype message: str - """ - - _validation = { - "name_available": {"readonly": True}, - "reason": {"readonly": True}, - "message": {"readonly": True}, - } - - _attribute_map = { - "name_available": {"key": "nameAvailable", "type": "bool"}, - "reason": {"key": "reason", "type": "str"}, - "message": {"key": "message", "type": "str"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.name_available = None - self.reason = None - self.message = None - - -class CloudErrorBody(_serialization.Model): - """An error response from Key Vault resource provider. - - :ivar code: Error code. This is a mnemonic that can be consumed programmatically. - :vartype code: str - :ivar message: User friendly error message. The message is typically localized and may vary - with service version. - :vartype message: str - """ - - _attribute_map = { - "code": {"key": "code", "type": "str"}, - "message": {"key": "message", "type": "str"}, - } - - def __init__(self, *, code: Optional[str] = None, message: Optional[str] = None, **kwargs: Any) -> None: - """ - :keyword code: Error code. This is a mnemonic that can be consumed programmatically. - :paramtype code: str - :keyword message: User friendly error message. The message is typically localized and may vary - with service version. - :paramtype message: str - """ - super().__init__(**kwargs) - self.code = code - self.message = message - - -class DeletedManagedHsm(_serialization.Model): - """DeletedManagedHsm. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The Azure Resource Manager resource ID for the deleted managed HSM Pool. - :vartype id: str - :ivar name: The name of the managed HSM Pool. - :vartype name: str - :ivar type: The resource type of the managed HSM Pool. - :vartype type: str - :ivar properties: Properties of the deleted managed HSM. - :vartype properties: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletedManagedHsmProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "properties": {"key": "properties", "type": "DeletedManagedHsmProperties"}, - } - - def __init__(self, *, properties: Optional["_models.DeletedManagedHsmProperties"] = None, **kwargs: Any) -> None: - """ - :keyword properties: Properties of the deleted managed HSM. - :paramtype properties: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletedManagedHsmProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.properties = properties - - -class DeletedManagedHsmListResult(_serialization.Model): - """List of deleted managed HSM Pools. - - :ivar value: The list of deleted managed HSM Pools. - :vartype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletedManagedHsm] - :ivar next_link: The URL to get the next set of deleted managed HSM Pools. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[DeletedManagedHsm]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, - *, - value: Optional[List["_models.DeletedManagedHsm"]] = None, - next_link: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword value: The list of deleted managed HSM Pools. - :paramtype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletedManagedHsm] - :keyword next_link: The URL to get the next set of deleted managed HSM Pools. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class DeletedManagedHsmProperties(_serialization.Model): - """Properties of the deleted managed HSM. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar mhsm_id: The resource id of the original managed HSM. - :vartype mhsm_id: str - :ivar location: The location of the original managed HSM. - :vartype location: str - :ivar deletion_date: The deleted date. - :vartype deletion_date: ~datetime.datetime - :ivar scheduled_purge_date: The scheduled purged date. - :vartype scheduled_purge_date: ~datetime.datetime - :ivar purge_protection_enabled: Purge protection status of the original managed HSM. - :vartype purge_protection_enabled: bool - :ivar tags: Tags of the original managed HSM. - :vartype tags: dict[str, str] - """ - - _validation = { - "mhsm_id": {"readonly": True}, - "location": {"readonly": True}, - "deletion_date": {"readonly": True}, - "scheduled_purge_date": {"readonly": True}, - "purge_protection_enabled": {"readonly": True}, - "tags": {"readonly": True}, - } - - _attribute_map = { - "mhsm_id": {"key": "mhsmId", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "deletion_date": {"key": "deletionDate", "type": "iso-8601"}, - "scheduled_purge_date": {"key": "scheduledPurgeDate", "type": "iso-8601"}, - "purge_protection_enabled": {"key": "purgeProtectionEnabled", "type": "bool"}, - "tags": {"key": "tags", "type": "{str}"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.mhsm_id = None - self.location = None - self.deletion_date = None - self.scheduled_purge_date = None - self.purge_protection_enabled = None - self.tags = None - - -class DeletedVault(_serialization.Model): - """Deleted vault information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The resource ID for the deleted key vault. - :vartype id: str - :ivar name: The name of the key vault. - :vartype name: str - :ivar type: The resource type of the key vault. - :vartype type: str - :ivar properties: Properties of the vault. - :vartype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletedVaultProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "properties": {"key": "properties", "type": "DeletedVaultProperties"}, - } - - def __init__(self, *, properties: Optional["_models.DeletedVaultProperties"] = None, **kwargs: Any) -> None: - """ - :keyword properties: Properties of the vault. - :paramtype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletedVaultProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.properties = properties - - -class DeletedVaultListResult(_serialization.Model): - """List of vaults. - - :ivar value: The list of deleted vaults. - :vartype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletedVault] - :ivar next_link: The URL to get the next set of deleted vaults. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[DeletedVault]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.DeletedVault"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of deleted vaults. - :paramtype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletedVault] - :keyword next_link: The URL to get the next set of deleted vaults. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class DeletedVaultProperties(_serialization.Model): - """Properties of the deleted vault. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar vault_id: The resource id of the original vault. - :vartype vault_id: str - :ivar location: The location of the original vault. - :vartype location: str - :ivar deletion_date: The deleted date. - :vartype deletion_date: ~datetime.datetime - :ivar scheduled_purge_date: The scheduled purged date. - :vartype scheduled_purge_date: ~datetime.datetime - :ivar tags: Tags of the original vault. - :vartype tags: dict[str, str] - :ivar purge_protection_enabled: Purge protection status of the original vault. - :vartype purge_protection_enabled: bool - """ - - _validation = { - "vault_id": {"readonly": True}, - "location": {"readonly": True}, - "deletion_date": {"readonly": True}, - "scheduled_purge_date": {"readonly": True}, - "tags": {"readonly": True}, - "purge_protection_enabled": {"readonly": True}, - } - - _attribute_map = { - "vault_id": {"key": "vaultId", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "deletion_date": {"key": "deletionDate", "type": "iso-8601"}, - "scheduled_purge_date": {"key": "scheduledPurgeDate", "type": "iso-8601"}, - "tags": {"key": "tags", "type": "{str}"}, - "purge_protection_enabled": {"key": "purgeProtectionEnabled", "type": "bool"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.vault_id = None - self.location = None - self.deletion_date = None - self.scheduled_purge_date = None - self.tags = None - self.purge_protection_enabled = None - - -class DimensionProperties(_serialization.Model): - """Type of operation: get, read, delete, etc. - - :ivar name: Name of dimension. - :vartype name: str - :ivar display_name: Display name of dimension. - :vartype display_name: str - :ivar to_be_exported_for_shoebox: Property to specify whether the dimension should be exported - for Shoebox. - :vartype to_be_exported_for_shoebox: bool - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display_name": {"key": "displayName", "type": "str"}, - "to_be_exported_for_shoebox": {"key": "toBeExportedForShoebox", "type": "bool"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display_name: Optional[str] = None, - to_be_exported_for_shoebox: Optional[bool] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Name of dimension. - :paramtype name: str - :keyword display_name: Display name of dimension. - :paramtype display_name: str - :keyword to_be_exported_for_shoebox: Property to specify whether the dimension should be - exported for Shoebox. - :paramtype to_be_exported_for_shoebox: bool - """ - super().__init__(**kwargs) - self.name = name - self.display_name = display_name - self.to_be_exported_for_shoebox = to_be_exported_for_shoebox - - -class Error(_serialization.Model): - """The server error. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar code: The error code. - :vartype code: str - :ivar message: The error message. - :vartype message: str - :ivar inner_error: The inner error, contains a more specific error code. - :vartype inner_error: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Error - """ - - _validation = { - "code": {"readonly": True}, - "message": {"readonly": True}, - "inner_error": {"readonly": True}, - } - - _attribute_map = { - "code": {"key": "code", "type": "str"}, - "message": {"key": "message", "type": "str"}, - "inner_error": {"key": "innererror", "type": "Error"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.code = None - self.message = None - self.inner_error = None - - -class IPRule(_serialization.Model): - """A rule governing the accessibility of a vault from a specific ip address or ip range. - - All required parameters must be populated in order to send to server. - - :ivar value: An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP address) - or '124.56.78.0/24' (all addresses that start with 124.56.78). Required. - :vartype value: str - """ - - _validation = { - "value": {"required": True}, - } - - _attribute_map = { - "value": {"key": "value", "type": "str"}, - } - - def __init__(self, *, value: str, **kwargs: Any) -> None: - """ - :keyword value: An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP - address) or '124.56.78.0/24' (all addresses that start with 124.56.78). Required. - :paramtype value: str - """ - super().__init__(**kwargs) - self.value = value - - -class Resource(_serialization.Model): - """Key Vault resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = None - self.tags = None - - -class Key(Resource): # pylint: disable=too-many-instance-attributes - """The key resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar attributes: The attributes of the key. - :vartype attributes: ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyAttributes - :ivar kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: "EC", - "EC-HSM", "RSA", and "RSA-HSM". - :vartype kty: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.JsonWebKeyType - :ivar key_ops: - :vartype key_ops: list[str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.JsonWebKeyOperation] - :ivar key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. - :vartype key_size: int - :ivar curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :vartype curve_name: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.JsonWebKeyCurveName - :ivar key_uri: The URI to retrieve the current version of the key. - :vartype key_uri: str - :ivar key_uri_with_version: The URI to retrieve the specific version of the key. - :vartype key_uri_with_version: str - :ivar rotation_policy: Key rotation policy in response. It will be used for both output and - input. Omitted if empty. - :vartype rotation_policy: ~azure.mgmt.keyvault.v2021_06_01_preview.models.RotationPolicy - :ivar release_policy: Key release policy in response. It will be used for both output and - input. Omitted if empty. - :vartype release_policy: ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyReleasePolicy - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - "key_uri": {"readonly": True}, - "key_uri_with_version": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "attributes": {"key": "properties.attributes", "type": "KeyAttributes"}, - "kty": {"key": "properties.kty", "type": "str"}, - "key_ops": {"key": "properties.keyOps", "type": "[str]"}, - "key_size": {"key": "properties.keySize", "type": "int"}, - "curve_name": {"key": "properties.curveName", "type": "str"}, - "key_uri": {"key": "properties.keyUri", "type": "str"}, - "key_uri_with_version": {"key": "properties.keyUriWithVersion", "type": "str"}, - "rotation_policy": {"key": "properties.rotationPolicy", "type": "RotationPolicy"}, - "release_policy": {"key": "properties.release_policy", "type": "KeyReleasePolicy"}, - } - - def __init__( - self, - *, - attributes: Optional["_models.KeyAttributes"] = None, - kty: Optional[Union[str, "_models.JsonWebKeyType"]] = None, - key_ops: Optional[List[Union[str, "_models.JsonWebKeyOperation"]]] = None, - key_size: Optional[int] = None, - curve_name: Optional[Union[str, "_models.JsonWebKeyCurveName"]] = None, - rotation_policy: Optional["_models.RotationPolicy"] = None, - release_policy: Optional["_models.KeyReleasePolicy"] = None, - **kwargs: Any - ) -> None: - """ - :keyword attributes: The attributes of the key. - :paramtype attributes: ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyAttributes - :keyword kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: - "EC", "EC-HSM", "RSA", and "RSA-HSM". - :paramtype kty: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.JsonWebKeyType - :keyword key_ops: - :paramtype key_ops: list[str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.JsonWebKeyOperation] - :keyword key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. - :paramtype key_size: int - :keyword curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :paramtype curve_name: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.JsonWebKeyCurveName - :keyword rotation_policy: Key rotation policy in response. It will be used for both output and - input. Omitted if empty. - :paramtype rotation_policy: ~azure.mgmt.keyvault.v2021_06_01_preview.models.RotationPolicy - :keyword release_policy: Key release policy in response. It will be used for both output and - input. Omitted if empty. - :paramtype release_policy: ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyReleasePolicy - """ - super().__init__(**kwargs) - self.attributes = attributes - self.kty = kty - self.key_ops = key_ops - self.key_size = key_size - self.curve_name = curve_name - self.key_uri = None - self.key_uri_with_version = None - self.rotation_policy = rotation_policy - self.release_policy = release_policy - - -class KeyAttributes(_serialization.Model): - """The object attributes managed by the Azure Key Vault service. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar enabled: Determines whether or not the object is enabled. - :vartype enabled: bool - :ivar not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :vartype not_before: int - :ivar expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :vartype expires: int - :ivar created: Creation time in seconds since 1970-01-01T00:00:00Z. - :vartype created: int - :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: int - :ivar recovery_level: The deletion recovery level currently in effect for the object. If it - contains 'Purgeable', then the object can be permanently deleted by a privileged user; - otherwise, only the system can purge the object at the end of the retention interval. Known - values are: "Purgeable", "Recoverable+Purgeable", "Recoverable", and - "Recoverable+ProtectedSubscription". - :vartype recovery_level: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletionRecoveryLevel - :ivar exportable: Indicates if the private key can be exported. - :vartype exportable: bool - """ - - _validation = { - "created": {"readonly": True}, - "updated": {"readonly": True}, - "recovery_level": {"readonly": True}, - } - - _attribute_map = { - "enabled": {"key": "enabled", "type": "bool"}, - "not_before": {"key": "nbf", "type": "int"}, - "expires": {"key": "exp", "type": "int"}, - "created": {"key": "created", "type": "int"}, - "updated": {"key": "updated", "type": "int"}, - "recovery_level": {"key": "recoveryLevel", "type": "str"}, - "exportable": {"key": "exportable", "type": "bool"}, - } - - def __init__( - self, - *, - enabled: Optional[bool] = None, - not_before: Optional[int] = None, - expires: Optional[int] = None, - exportable: Optional[bool] = None, - **kwargs: Any - ) -> None: - """ - :keyword enabled: Determines whether or not the object is enabled. - :paramtype enabled: bool - :keyword not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :paramtype not_before: int - :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :paramtype expires: int - :keyword exportable: Indicates if the private key can be exported. - :paramtype exportable: bool - """ - super().__init__(**kwargs) - self.enabled = enabled - self.not_before = not_before - self.expires = expires - self.created = None - self.updated = None - self.recovery_level = None - self.exportable = exportable - - -class KeyCreateParameters(_serialization.Model): - """The parameters used to create a key. - - All required parameters must be populated in order to send to server. - - :ivar tags: The tags that will be assigned to the key. - :vartype tags: dict[str, str] - :ivar properties: The properties of the key to be created. Required. - :vartype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyProperties - """ - - _validation = { - "properties": {"required": True}, - } - - _attribute_map = { - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "KeyProperties"}, - } - - def __init__( - self, *, properties: "_models.KeyProperties", tags: Optional[Dict[str, str]] = None, **kwargs: Any - ) -> None: - """ - :keyword tags: The tags that will be assigned to the key. - :paramtype tags: dict[str, str] - :keyword properties: The properties of the key to be created. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyProperties - """ - super().__init__(**kwargs) - self.tags = tags - self.properties = properties - - -class KeyListResult(_serialization.Model): - """The page of keys. - - :ivar value: The key resources. - :vartype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.Key] - :ivar next_link: The URL to get the next page of keys. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Key]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Key"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The key resources. - :paramtype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.Key] - :keyword next_link: The URL to get the next page of keys. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class KeyProperties(_serialization.Model): - """The properties of the key. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar attributes: The attributes of the key. - :vartype attributes: ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyAttributes - :ivar kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: "EC", - "EC-HSM", "RSA", and "RSA-HSM". - :vartype kty: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.JsonWebKeyType - :ivar key_ops: - :vartype key_ops: list[str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.JsonWebKeyOperation] - :ivar key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. - :vartype key_size: int - :ivar curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :vartype curve_name: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.JsonWebKeyCurveName - :ivar key_uri: The URI to retrieve the current version of the key. - :vartype key_uri: str - :ivar key_uri_with_version: The URI to retrieve the specific version of the key. - :vartype key_uri_with_version: str - :ivar rotation_policy: Key rotation policy in response. It will be used for both output and - input. Omitted if empty. - :vartype rotation_policy: ~azure.mgmt.keyvault.v2021_06_01_preview.models.RotationPolicy - :ivar release_policy: Key release policy in response. It will be used for both output and - input. Omitted if empty. - :vartype release_policy: ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyReleasePolicy - """ - - _validation = { - "key_uri": {"readonly": True}, - "key_uri_with_version": {"readonly": True}, - } - - _attribute_map = { - "attributes": {"key": "attributes", "type": "KeyAttributes"}, - "kty": {"key": "kty", "type": "str"}, - "key_ops": {"key": "keyOps", "type": "[str]"}, - "key_size": {"key": "keySize", "type": "int"}, - "curve_name": {"key": "curveName", "type": "str"}, - "key_uri": {"key": "keyUri", "type": "str"}, - "key_uri_with_version": {"key": "keyUriWithVersion", "type": "str"}, - "rotation_policy": {"key": "rotationPolicy", "type": "RotationPolicy"}, - "release_policy": {"key": "release_policy", "type": "KeyReleasePolicy"}, - } - - def __init__( - self, - *, - attributes: Optional["_models.KeyAttributes"] = None, - kty: Optional[Union[str, "_models.JsonWebKeyType"]] = None, - key_ops: Optional[List[Union[str, "_models.JsonWebKeyOperation"]]] = None, - key_size: Optional[int] = None, - curve_name: Optional[Union[str, "_models.JsonWebKeyCurveName"]] = None, - rotation_policy: Optional["_models.RotationPolicy"] = None, - release_policy: Optional["_models.KeyReleasePolicy"] = None, - **kwargs: Any - ) -> None: - """ - :keyword attributes: The attributes of the key. - :paramtype attributes: ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyAttributes - :keyword kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: - "EC", "EC-HSM", "RSA", and "RSA-HSM". - :paramtype kty: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.JsonWebKeyType - :keyword key_ops: - :paramtype key_ops: list[str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.JsonWebKeyOperation] - :keyword key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. - :paramtype key_size: int - :keyword curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :paramtype curve_name: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.JsonWebKeyCurveName - :keyword rotation_policy: Key rotation policy in response. It will be used for both output and - input. Omitted if empty. - :paramtype rotation_policy: ~azure.mgmt.keyvault.v2021_06_01_preview.models.RotationPolicy - :keyword release_policy: Key release policy in response. It will be used for both output and - input. Omitted if empty. - :paramtype release_policy: ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyReleasePolicy - """ - super().__init__(**kwargs) - self.attributes = attributes - self.kty = kty - self.key_ops = key_ops - self.key_size = key_size - self.curve_name = curve_name - self.key_uri = None - self.key_uri_with_version = None - self.rotation_policy = rotation_policy - self.release_policy = release_policy - - -class KeyReleasePolicy(_serialization.Model): - """KeyReleasePolicy. - - :ivar content_type: Content type and version of key release policy. - :vartype content_type: str - :ivar data: Blob encoding the policy rules under which the key can be released. - :vartype data: bytes - """ - - _attribute_map = { - "content_type": {"key": "contentType", "type": "str"}, - "data": {"key": "data", "type": "base64"}, - } - - def __init__( - self, *, content_type: str = "application/json; charset=utf-8", data: Optional[bytes] = None, **kwargs: Any - ) -> None: - """ - :keyword content_type: Content type and version of key release policy. - :paramtype content_type: str - :keyword data: Blob encoding the policy rules under which the key can be released. - :paramtype data: bytes - """ - super().__init__(**kwargs) - self.content_type = content_type - self.data = data - - -class KeyRotationPolicyAttributes(_serialization.Model): - """KeyRotationPolicyAttributes. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar created: Creation time in seconds since 1970-01-01T00:00:00Z. - :vartype created: int - :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: int - :ivar expiry_time: The expiration time for the new key version. It should be in ISO8601 format. - Eg: 'P90D', 'P1Y'. - :vartype expiry_time: str - """ - - _validation = { - "created": {"readonly": True}, - "updated": {"readonly": True}, - } - - _attribute_map = { - "created": {"key": "created", "type": "int"}, - "updated": {"key": "updated", "type": "int"}, - "expiry_time": {"key": "expiryTime", "type": "str"}, - } - - def __init__(self, *, expiry_time: Optional[str] = None, **kwargs: Any) -> None: - """ - :keyword expiry_time: The expiration time for the new key version. It should be in ISO8601 - format. Eg: 'P90D', 'P1Y'. - :paramtype expiry_time: str - """ - super().__init__(**kwargs) - self.created = None - self.updated = None - self.expiry_time = expiry_time - - -class LifetimeAction(_serialization.Model): - """LifetimeAction. - - :ivar trigger: The trigger of key rotation policy lifetimeAction. - :vartype trigger: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Trigger - :ivar action: The action of key rotation policy lifetimeAction. - :vartype action: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Action - """ - - _attribute_map = { - "trigger": {"key": "trigger", "type": "Trigger"}, - "action": {"key": "action", "type": "Action"}, - } - - def __init__( - self, *, trigger: Optional["_models.Trigger"] = None, action: Optional["_models.Action"] = None, **kwargs: Any - ) -> None: - """ - :keyword trigger: The trigger of key rotation policy lifetimeAction. - :paramtype trigger: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Trigger - :keyword action: The action of key rotation policy lifetimeAction. - :paramtype action: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Action - """ - super().__init__(**kwargs) - self.trigger = trigger - self.action = action - - -class LogSpecification(_serialization.Model): - """Log specification of operation. - - :ivar name: Name of log specification. - :vartype name: str - :ivar display_name: Display name of log specification. - :vartype display_name: str - :ivar blob_duration: Blob duration of specification. - :vartype blob_duration: str - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display_name": {"key": "displayName", "type": "str"}, - "blob_duration": {"key": "blobDuration", "type": "str"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display_name: Optional[str] = None, - blob_duration: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Name of log specification. - :paramtype name: str - :keyword display_name: Display name of log specification. - :paramtype display_name: str - :keyword blob_duration: Blob duration of specification. - :paramtype blob_duration: str - """ - super().__init__(**kwargs) - self.name = name - self.display_name = display_name - self.blob_duration = blob_duration - - -class ManagedHsmResource(_serialization.Model): - """Managed HSM resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The Azure Resource Manager resource ID for the managed HSM Pool. - :vartype id: str - :ivar name: The name of the managed HSM Pool. - :vartype name: str - :ivar type: The resource type of the managed HSM Pool. - :vartype type: str - :ivar location: The supported Azure location where the managed HSM Pool should be created. - :vartype location: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSku - :ivar tags: Resource tags. - :vartype tags: dict[str, str] - :ivar system_data: Metadata pertaining to creation and last modification of the key vault - resource. - :vartype system_data: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SystemData - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "system_data": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "sku": {"key": "sku", "type": "ManagedHsmSku"}, - "tags": {"key": "tags", "type": "{str}"}, - "system_data": {"key": "systemData", "type": "SystemData"}, - } - - def __init__( - self, - *, - location: Optional[str] = None, - sku: Optional["_models.ManagedHsmSku"] = None, - tags: Optional[Dict[str, str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the managed HSM Pool should be created. - :paramtype location: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSku - :keyword tags: Resource tags. - :paramtype tags: dict[str, str] - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = location - self.sku = sku - self.tags = tags - self.system_data = None - - -class ManagedHsm(ManagedHsmResource): - """Resource information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The Azure Resource Manager resource ID for the managed HSM Pool. - :vartype id: str - :ivar name: The name of the managed HSM Pool. - :vartype name: str - :ivar type: The resource type of the managed HSM Pool. - :vartype type: str - :ivar location: The supported Azure location where the managed HSM Pool should be created. - :vartype location: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSku - :ivar tags: Resource tags. - :vartype tags: dict[str, str] - :ivar system_data: Metadata pertaining to creation and last modification of the key vault - resource. - :vartype system_data: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SystemData - :ivar properties: Properties of the managed HSM. - :vartype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "system_data": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "sku": {"key": "sku", "type": "ManagedHsmSku"}, - "tags": {"key": "tags", "type": "{str}"}, - "system_data": {"key": "systemData", "type": "SystemData"}, - "properties": {"key": "properties", "type": "ManagedHsmProperties"}, - } - - def __init__( - self, - *, - location: Optional[str] = None, - sku: Optional["_models.ManagedHsmSku"] = None, - tags: Optional[Dict[str, str]] = None, - properties: Optional["_models.ManagedHsmProperties"] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the managed HSM Pool should be created. - :paramtype location: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSku - :keyword tags: Resource tags. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the managed HSM. - :paramtype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmProperties - """ - super().__init__(location=location, sku=sku, tags=tags, **kwargs) - self.properties = properties - - -class ManagedHsmError(_serialization.Model): - """The error exception. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar error: The server error. - :vartype error: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Error - """ - - _validation = { - "error": {"readonly": True}, - } - - _attribute_map = { - "error": {"key": "error", "type": "Error"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.error = None - - -class ManagedHsmListResult(_serialization.Model): - """List of managed HSM Pools. - - :ivar value: The list of managed HSM Pools. - :vartype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm] - :ivar next_link: The URL to get the next set of managed HSM Pools. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[ManagedHsm]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.ManagedHsm"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of managed HSM Pools. - :paramtype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm] - :keyword next_link: The URL to get the next set of managed HSM Pools. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class ManagedHsmProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Properties of the managed HSM Pool. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the managed HSM pool. - :vartype tenant_id: str - :ivar initial_admin_object_ids: Array of initial administrators object ids for this managed hsm - pool. - :vartype initial_admin_object_ids: list[str] - :ivar hsm_uri: The URI of the managed hsm pool for performing operations on keys. - :vartype hsm_uri: str - :ivar enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this managed HSM pool. Soft delete is enabled by default for all managed HSMs and - is immutable. - :vartype enable_soft_delete: bool - :ivar soft_delete_retention_in_days: Soft deleted data retention days. When you delete an HSM - or a key, it will remain recoverable for the configured retention period or for a default - period of 90 days. It accepts values between 7 and 90. - :vartype soft_delete_retention_in_days: int - :ivar enable_purge_protection: Property specifying whether protection against purge is enabled - for this managed HSM pool. Setting this property to true activates protection against purge for - this managed HSM pool and its content - only the Managed HSM service may initiate a hard, - irrecoverable deletion. Enabling this functionality is irreversible. - :vartype enable_purge_protection: bool - :ivar create_mode: The create mode to indicate whether the resource is being created or is - being recovered from a deleted resource. Known values are: "recover" and "default". - :vartype create_mode: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.CreateMode - :ivar status_message: Resource Status Message. - :vartype status_message: str - :ivar provisioning_state: Provisioning state. Known values are: "Succeeded", "Provisioning", - "Failed", "Updating", "Deleting", "Activated", "SecurityDomainRestore", and "Restoring". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.ProvisioningState - :ivar network_acls: Rules governing the accessibility of the key vault from specific network - locations. - :vartype network_acls: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMNetworkRuleSet - :ivar private_endpoint_connections: List of private endpoint connections associated with the - managed hsm pool. - :vartype private_endpoint_connections: - list[~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnectionItem] - :ivar public_network_access: Control permission to the managed HSM from public networks. Known - values are: "Enabled" and "Disabled". - :vartype public_network_access: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.PublicNetworkAccess - :ivar scheduled_purge_date: The scheduled purge date in UTC. - :vartype scheduled_purge_date: ~datetime.datetime - """ - - _validation = { - "hsm_uri": {"readonly": True}, - "status_message": {"readonly": True}, - "provisioning_state": {"readonly": True}, - "private_endpoint_connections": {"readonly": True}, - "scheduled_purge_date": {"readonly": True}, - } - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "initial_admin_object_ids": {"key": "initialAdminObjectIds", "type": "[str]"}, - "hsm_uri": {"key": "hsmUri", "type": "str"}, - "enable_soft_delete": {"key": "enableSoftDelete", "type": "bool"}, - "soft_delete_retention_in_days": {"key": "softDeleteRetentionInDays", "type": "int"}, - "enable_purge_protection": {"key": "enablePurgeProtection", "type": "bool"}, - "create_mode": {"key": "createMode", "type": "str"}, - "status_message": {"key": "statusMessage", "type": "str"}, - "provisioning_state": {"key": "provisioningState", "type": "str"}, - "network_acls": {"key": "networkAcls", "type": "MHSMNetworkRuleSet"}, - "private_endpoint_connections": { - "key": "privateEndpointConnections", - "type": "[MHSMPrivateEndpointConnectionItem]", - }, - "public_network_access": {"key": "publicNetworkAccess", "type": "str"}, - "scheduled_purge_date": {"key": "scheduledPurgeDate", "type": "iso-8601"}, - } - - def __init__( - self, - *, - tenant_id: Optional[str] = None, - initial_admin_object_ids: Optional[List[str]] = None, - enable_soft_delete: bool = True, - soft_delete_retention_in_days: int = 90, - enable_purge_protection: bool = True, - create_mode: Optional[Union[str, "_models.CreateMode"]] = None, - network_acls: Optional["_models.MHSMNetworkRuleSet"] = None, - public_network_access: Union[str, "_models.PublicNetworkAccess"] = "Enabled", - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the managed HSM pool. - :paramtype tenant_id: str - :keyword initial_admin_object_ids: Array of initial administrators object ids for this managed - hsm pool. - :paramtype initial_admin_object_ids: list[str] - :keyword enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this managed HSM pool. Soft delete is enabled by default for all managed HSMs and - is immutable. - :paramtype enable_soft_delete: bool - :keyword soft_delete_retention_in_days: Soft deleted data retention days. When you delete an - HSM or a key, it will remain recoverable for the configured retention period or for a default - period of 90 days. It accepts values between 7 and 90. - :paramtype soft_delete_retention_in_days: int - :keyword enable_purge_protection: Property specifying whether protection against purge is - enabled for this managed HSM pool. Setting this property to true activates protection against - purge for this managed HSM pool and its content - only the Managed HSM service may initiate a - hard, irrecoverable deletion. Enabling this functionality is irreversible. - :paramtype enable_purge_protection: bool - :keyword create_mode: The create mode to indicate whether the resource is being created or is - being recovered from a deleted resource. Known values are: "recover" and "default". - :paramtype create_mode: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.CreateMode - :keyword network_acls: Rules governing the accessibility of the key vault from specific network - locations. - :paramtype network_acls: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMNetworkRuleSet - :keyword public_network_access: Control permission to the managed HSM from public networks. - Known values are: "Enabled" and "Disabled". - :paramtype public_network_access: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.PublicNetworkAccess - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.initial_admin_object_ids = initial_admin_object_ids - self.hsm_uri = None - self.enable_soft_delete = enable_soft_delete - self.soft_delete_retention_in_days = soft_delete_retention_in_days - self.enable_purge_protection = enable_purge_protection - self.create_mode = create_mode - self.status_message = None - self.provisioning_state = None - self.network_acls = network_acls - self.private_endpoint_connections = None - self.public_network_access = public_network_access - self.scheduled_purge_date = None - - -class ManagedHsmSku(_serialization.Model): - """SKU details. - - All required parameters must be populated in order to send to server. - - :ivar family: SKU Family of the managed HSM Pool. "B" - :vartype family: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSkuFamily - :ivar name: SKU of the managed HSM Pool. Required. Known values are: "Standard_B1", - "Custom_B32", and "Custom_B6". - :vartype name: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSkuName - """ - - _validation = { - "family": {"required": True}, - "name": {"required": True}, - } - - _attribute_map = { - "family": {"key": "family", "type": "str"}, - "name": {"key": "name", "type": "str"}, - } - - def __init__( - self, - *, - family: Union[str, "_models.ManagedHsmSkuFamily"] = "B", - name: Union[str, "_models.ManagedHsmSkuName"], - **kwargs: Any - ) -> None: - """ - :keyword family: SKU Family of the managed HSM Pool. "B" - :paramtype family: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSkuFamily - :keyword name: SKU of the managed HSM Pool. Required. Known values are: "Standard_B1", - "Custom_B32", and "Custom_B6". - :paramtype name: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSkuName - """ - super().__init__(**kwargs) - self.family = family - self.name = name - - -class MetricSpecification(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Metric specification of operation. - - :ivar name: Name of metric specification. - :vartype name: str - :ivar display_name: Display name of metric specification. - :vartype display_name: str - :ivar display_description: Display description of metric specification. - :vartype display_description: str - :ivar unit: The metric unit. Possible values include: 'Bytes', 'Count', 'Milliseconds'. - :vartype unit: str - :ivar aggregation_type: The metric aggregation type. Possible values include: 'Average', - 'Count', 'Total'. - :vartype aggregation_type: str - :ivar supported_aggregation_types: The supported aggregation types for the metrics. - :vartype supported_aggregation_types: list[str] - :ivar supported_time_grain_types: The supported time grain types for the metrics. - :vartype supported_time_grain_types: list[str] - :ivar lock_aggregation_type: The metric lock aggregation type. - :vartype lock_aggregation_type: str - :ivar dimensions: The dimensions of metric. - :vartype dimensions: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.DimensionProperties] - :ivar fill_gap_with_zero: Property to specify whether to fill gap with zero. - :vartype fill_gap_with_zero: bool - :ivar internal_metric_name: The internal metric name. - :vartype internal_metric_name: str - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display_name": {"key": "displayName", "type": "str"}, - "display_description": {"key": "displayDescription", "type": "str"}, - "unit": {"key": "unit", "type": "str"}, - "aggregation_type": {"key": "aggregationType", "type": "str"}, - "supported_aggregation_types": {"key": "supportedAggregationTypes", "type": "[str]"}, - "supported_time_grain_types": {"key": "supportedTimeGrainTypes", "type": "[str]"}, - "lock_aggregation_type": {"key": "lockAggregationType", "type": "str"}, - "dimensions": {"key": "dimensions", "type": "[DimensionProperties]"}, - "fill_gap_with_zero": {"key": "fillGapWithZero", "type": "bool"}, - "internal_metric_name": {"key": "internalMetricName", "type": "str"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display_name: Optional[str] = None, - display_description: Optional[str] = None, - unit: Optional[str] = None, - aggregation_type: Optional[str] = None, - supported_aggregation_types: Optional[List[str]] = None, - supported_time_grain_types: Optional[List[str]] = None, - lock_aggregation_type: Optional[str] = None, - dimensions: Optional[List["_models.DimensionProperties"]] = None, - fill_gap_with_zero: Optional[bool] = None, - internal_metric_name: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Name of metric specification. - :paramtype name: str - :keyword display_name: Display name of metric specification. - :paramtype display_name: str - :keyword display_description: Display description of metric specification. - :paramtype display_description: str - :keyword unit: The metric unit. Possible values include: 'Bytes', 'Count', 'Milliseconds'. - :paramtype unit: str - :keyword aggregation_type: The metric aggregation type. Possible values include: 'Average', - 'Count', 'Total'. - :paramtype aggregation_type: str - :keyword supported_aggregation_types: The supported aggregation types for the metrics. - :paramtype supported_aggregation_types: list[str] - :keyword supported_time_grain_types: The supported time grain types for the metrics. - :paramtype supported_time_grain_types: list[str] - :keyword lock_aggregation_type: The metric lock aggregation type. - :paramtype lock_aggregation_type: str - :keyword dimensions: The dimensions of metric. - :paramtype dimensions: - list[~azure.mgmt.keyvault.v2021_06_01_preview.models.DimensionProperties] - :keyword fill_gap_with_zero: Property to specify whether to fill gap with zero. - :paramtype fill_gap_with_zero: bool - :keyword internal_metric_name: The internal metric name. - :paramtype internal_metric_name: str - """ - super().__init__(**kwargs) - self.name = name - self.display_name = display_name - self.display_description = display_description - self.unit = unit - self.aggregation_type = aggregation_type - self.supported_aggregation_types = supported_aggregation_types - self.supported_time_grain_types = supported_time_grain_types - self.lock_aggregation_type = lock_aggregation_type - self.dimensions = dimensions - self.fill_gap_with_zero = fill_gap_with_zero - self.internal_metric_name = internal_metric_name - - -class MHSMIPRule(_serialization.Model): - """A rule governing the accessibility of a managed hsm pool from a specific ip address or ip - range. - - All required parameters must be populated in order to send to server. - - :ivar value: An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP address) - or '124.56.78.0/24' (all addresses that start with 124.56.78). Required. - :vartype value: str - """ - - _validation = { - "value": {"required": True}, - } - - _attribute_map = { - "value": {"key": "value", "type": "str"}, - } - - def __init__(self, *, value: str, **kwargs: Any) -> None: - """ - :keyword value: An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP - address) or '124.56.78.0/24' (all addresses that start with 124.56.78). Required. - :paramtype value: str - """ - super().__init__(**kwargs) - self.value = value - - -class MHSMNetworkRuleSet(_serialization.Model): - """A set of rules governing the network accessibility of a managed hsm pool. - - :ivar bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or - 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and - "None". - :vartype bypass: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.NetworkRuleBypassOptions - :ivar default_action: The default action when no rule from ipRules and from virtualNetworkRules - match. This is only used after the bypass property has been evaluated. Known values are: - "Allow" and "Deny". - :vartype default_action: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.NetworkRuleAction - :ivar ip_rules: The list of IP address rules. - :vartype ip_rules: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMIPRule] - :ivar virtual_network_rules: The list of virtual network rules. - :vartype virtual_network_rules: - list[~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMVirtualNetworkRule] - """ - - _attribute_map = { - "bypass": {"key": "bypass", "type": "str"}, - "default_action": {"key": "defaultAction", "type": "str"}, - "ip_rules": {"key": "ipRules", "type": "[MHSMIPRule]"}, - "virtual_network_rules": {"key": "virtualNetworkRules", "type": "[MHSMVirtualNetworkRule]"}, - } - - def __init__( - self, - *, - bypass: Optional[Union[str, "_models.NetworkRuleBypassOptions"]] = None, - default_action: Optional[Union[str, "_models.NetworkRuleAction"]] = None, - ip_rules: Optional[List["_models.MHSMIPRule"]] = None, - virtual_network_rules: Optional[List["_models.MHSMVirtualNetworkRule"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or - 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and - "None". - :paramtype bypass: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.NetworkRuleBypassOptions - :keyword default_action: The default action when no rule from ipRules and from - virtualNetworkRules match. This is only used after the bypass property has been evaluated. - Known values are: "Allow" and "Deny". - :paramtype default_action: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.NetworkRuleAction - :keyword ip_rules: The list of IP address rules. - :paramtype ip_rules: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMIPRule] - :keyword virtual_network_rules: The list of virtual network rules. - :paramtype virtual_network_rules: - list[~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMVirtualNetworkRule] - """ - super().__init__(**kwargs) - self.bypass = bypass - self.default_action = default_action - self.ip_rules = ip_rules - self.virtual_network_rules = virtual_network_rules - - -class MHSMPrivateEndpoint(_serialization.Model): - """Private endpoint object properties. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Full identifier of the private endpoint resource. - :vartype id: str - """ - - _validation = { - "id": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.id = None - - -class MHSMPrivateEndpointConnection(ManagedHsmResource): # pylint: disable=too-many-instance-attributes - """Private endpoint connection resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The Azure Resource Manager resource ID for the managed HSM Pool. - :vartype id: str - :ivar name: The name of the managed HSM Pool. - :vartype name: str - :ivar type: The resource type of the managed HSM Pool. - :vartype type: str - :ivar location: The supported Azure location where the managed HSM Pool should be created. - :vartype location: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSku - :ivar tags: Resource tags. - :vartype tags: dict[str, str] - :ivar system_data: Metadata pertaining to creation and last modification of the key vault - resource. - :vartype system_data: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SystemData - :ivar etag: Modified whenever there is a change in the state of private endpoint connection. - :vartype etag: str - :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpoint - :ivar private_link_service_connection_state: Approval state of the private link connection. - :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateLinkServiceConnectionState - :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values - are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnectionProvisioningState - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "system_data": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "sku": {"key": "sku", "type": "ManagedHsmSku"}, - "tags": {"key": "tags", "type": "{str}"}, - "system_data": {"key": "systemData", "type": "SystemData"}, - "etag": {"key": "etag", "type": "str"}, - "private_endpoint": {"key": "properties.privateEndpoint", "type": "MHSMPrivateEndpoint"}, - "private_link_service_connection_state": { - "key": "properties.privateLinkServiceConnectionState", - "type": "MHSMPrivateLinkServiceConnectionState", - }, - "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - location: Optional[str] = None, - sku: Optional["_models.ManagedHsmSku"] = None, - tags: Optional[Dict[str, str]] = None, - etag: Optional[str] = None, - private_endpoint: Optional["_models.MHSMPrivateEndpoint"] = None, - private_link_service_connection_state: Optional["_models.MHSMPrivateLinkServiceConnectionState"] = None, - provisioning_state: Optional[Union[str, "_models.PrivateEndpointConnectionProvisioningState"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the managed HSM Pool should be created. - :paramtype location: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSku - :keyword tags: Resource tags. - :paramtype tags: dict[str, str] - :keyword etag: Modified whenever there is a change in the state of private endpoint connection. - :paramtype etag: str - :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpoint - :keyword private_link_service_connection_state: Approval state of the private link connection. - :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateLinkServiceConnectionState - :keyword provisioning_state: Provisioning state of the private endpoint connection. Known - values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnectionProvisioningState - """ - super().__init__(location=location, sku=sku, tags=tags, **kwargs) - self.etag = etag - self.private_endpoint = private_endpoint - self.private_link_service_connection_state = private_link_service_connection_state - self.provisioning_state = provisioning_state - - -class MHSMPrivateEndpointConnectionItem(_serialization.Model): - """Private endpoint connection item. - - :ivar id: Id of private endpoint connection. - :vartype id: str - :ivar etag: Modified whenever there is a change in the state of private endpoint connection. - :vartype etag: str - :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpoint - :ivar private_link_service_connection_state: Approval state of the private link connection. - :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateLinkServiceConnectionState - :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values - are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnectionProvisioningState - """ - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "etag": {"key": "etag", "type": "str"}, - "private_endpoint": {"key": "properties.privateEndpoint", "type": "MHSMPrivateEndpoint"}, - "private_link_service_connection_state": { - "key": "properties.privateLinkServiceConnectionState", - "type": "MHSMPrivateLinkServiceConnectionState", - }, - "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - id: Optional[str] = None, # pylint: disable=redefined-builtin - etag: Optional[str] = None, - private_endpoint: Optional["_models.MHSMPrivateEndpoint"] = None, - private_link_service_connection_state: Optional["_models.MHSMPrivateLinkServiceConnectionState"] = None, - provisioning_state: Optional[Union[str, "_models.PrivateEndpointConnectionProvisioningState"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword id: Id of private endpoint connection. - :paramtype id: str - :keyword etag: Modified whenever there is a change in the state of private endpoint connection. - :paramtype etag: str - :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpoint - :keyword private_link_service_connection_state: Approval state of the private link connection. - :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateLinkServiceConnectionState - :keyword provisioning_state: Provisioning state of the private endpoint connection. Known - values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnectionProvisioningState - """ - super().__init__(**kwargs) - self.id = id - self.etag = etag - self.private_endpoint = private_endpoint - self.private_link_service_connection_state = private_link_service_connection_state - self.provisioning_state = provisioning_state - - -class MHSMPrivateEndpointConnectionsListResult(_serialization.Model): - """List of private endpoint connections associated with a managed HSM Pools. - - :ivar value: The private endpoint connection associated with a managed HSM Pools. - :vartype value: - list[~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection] - :ivar next_link: The URL to get the next set of managed HSM Pools. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[MHSMPrivateEndpointConnection]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, - *, - value: Optional[List["_models.MHSMPrivateEndpointConnection"]] = None, - next_link: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword value: The private endpoint connection associated with a managed HSM Pools. - :paramtype value: - list[~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection] - :keyword next_link: The URL to get the next set of managed HSM Pools. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class MHSMPrivateLinkResource(ManagedHsmResource): - """A private link resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The Azure Resource Manager resource ID for the managed HSM Pool. - :vartype id: str - :ivar name: The name of the managed HSM Pool. - :vartype name: str - :ivar type: The resource type of the managed HSM Pool. - :vartype type: str - :ivar location: The supported Azure location where the managed HSM Pool should be created. - :vartype location: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSku - :ivar tags: Resource tags. - :vartype tags: dict[str, str] - :ivar system_data: Metadata pertaining to creation and last modification of the key vault - resource. - :vartype system_data: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SystemData - :ivar group_id: Group identifier of private link resource. - :vartype group_id: str - :ivar required_members: Required member names of private link resource. - :vartype required_members: list[str] - :ivar required_zone_names: Required DNS zone names of the the private link resource. - :vartype required_zone_names: list[str] - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "system_data": {"readonly": True}, - "group_id": {"readonly": True}, - "required_members": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "sku": {"key": "sku", "type": "ManagedHsmSku"}, - "tags": {"key": "tags", "type": "{str}"}, - "system_data": {"key": "systemData", "type": "SystemData"}, - "group_id": {"key": "properties.groupId", "type": "str"}, - "required_members": {"key": "properties.requiredMembers", "type": "[str]"}, - "required_zone_names": {"key": "properties.requiredZoneNames", "type": "[str]"}, - } - - def __init__( - self, - *, - location: Optional[str] = None, - sku: Optional["_models.ManagedHsmSku"] = None, - tags: Optional[Dict[str, str]] = None, - required_zone_names: Optional[List[str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the managed HSM Pool should be created. - :paramtype location: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSku - :keyword tags: Resource tags. - :paramtype tags: dict[str, str] - :keyword required_zone_names: Required DNS zone names of the the private link resource. - :paramtype required_zone_names: list[str] - """ - super().__init__(location=location, sku=sku, tags=tags, **kwargs) - self.group_id = None - self.required_members = None - self.required_zone_names = required_zone_names - - -class MHSMPrivateLinkResourceListResult(_serialization.Model): - """A list of private link resources. - - :ivar value: Array of private link resources. - :vartype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateLinkResource] - """ - - _attribute_map = { - "value": {"key": "value", "type": "[MHSMPrivateLinkResource]"}, - } - - def __init__(self, *, value: Optional[List["_models.MHSMPrivateLinkResource"]] = None, **kwargs: Any) -> None: - """ - :keyword value: Array of private link resources. - :paramtype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateLinkResource] - """ - super().__init__(**kwargs) - self.value = value - - -class MHSMPrivateLinkServiceConnectionState(_serialization.Model): - """An object that represents the approval state of the private link connection. - - :ivar status: Indicates whether the connection has been approved, rejected or removed by the - key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :vartype status: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointServiceConnectionStatus - :ivar description: The reason for approval or rejection. - :vartype description: str - :ivar actions_required: A message indicating if changes on the service provider require any - updates on the consumer. "None" - :vartype actions_required: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.ActionsRequired - """ - - _attribute_map = { - "status": {"key": "status", "type": "str"}, - "description": {"key": "description", "type": "str"}, - "actions_required": {"key": "actionsRequired", "type": "str"}, - } - - def __init__( - self, - *, - status: Optional[Union[str, "_models.PrivateEndpointServiceConnectionStatus"]] = None, - description: Optional[str] = None, - actions_required: Optional[Union[str, "_models.ActionsRequired"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword status: Indicates whether the connection has been approved, rejected or removed by the - key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :paramtype status: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointServiceConnectionStatus - :keyword description: The reason for approval or rejection. - :paramtype description: str - :keyword actions_required: A message indicating if changes on the service provider require any - updates on the consumer. "None" - :paramtype actions_required: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.ActionsRequired - """ - super().__init__(**kwargs) - self.status = status - self.description = description - self.actions_required = actions_required - - -class MHSMVirtualNetworkRule(_serialization.Model): - """A rule governing the accessibility of a managed hsm pool from a specific virtual network. - - All required parameters must be populated in order to send to server. - - :ivar id: Full resource id of a vnet subnet, such as - '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. - Required. - :vartype id: str - """ - - _validation = { - "id": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - } - - def __init__(self, *, id: str, **kwargs: Any) -> None: # pylint: disable=redefined-builtin - """ - :keyword id: Full resource id of a vnet subnet, such as - '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. # pylint: disable=line-too-long - Required. - :paramtype id: str - """ - super().__init__(**kwargs) - self.id = id - - -class NetworkRuleSet(_serialization.Model): - """A set of rules governing the network accessibility of a vault. - - :ivar bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or - 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and - "None". - :vartype bypass: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.NetworkRuleBypassOptions - :ivar default_action: The default action when no rule from ipRules and from virtualNetworkRules - match. This is only used after the bypass property has been evaluated. Known values are: - "Allow" and "Deny". - :vartype default_action: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.NetworkRuleAction - :ivar ip_rules: The list of IP address rules. - :vartype ip_rules: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.IPRule] - :ivar virtual_network_rules: The list of virtual network rules. - :vartype virtual_network_rules: - list[~azure.mgmt.keyvault.v2021_06_01_preview.models.VirtualNetworkRule] - """ - - _attribute_map = { - "bypass": {"key": "bypass", "type": "str"}, - "default_action": {"key": "defaultAction", "type": "str"}, - "ip_rules": {"key": "ipRules", "type": "[IPRule]"}, - "virtual_network_rules": {"key": "virtualNetworkRules", "type": "[VirtualNetworkRule]"}, - } - - def __init__( - self, - *, - bypass: Optional[Union[str, "_models.NetworkRuleBypassOptions"]] = None, - default_action: Optional[Union[str, "_models.NetworkRuleAction"]] = None, - ip_rules: Optional[List["_models.IPRule"]] = None, - virtual_network_rules: Optional[List["_models.VirtualNetworkRule"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or - 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and - "None". - :paramtype bypass: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.NetworkRuleBypassOptions - :keyword default_action: The default action when no rule from ipRules and from - virtualNetworkRules match. This is only used after the bypass property has been evaluated. - Known values are: "Allow" and "Deny". - :paramtype default_action: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.NetworkRuleAction - :keyword ip_rules: The list of IP address rules. - :paramtype ip_rules: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.IPRule] - :keyword virtual_network_rules: The list of virtual network rules. - :paramtype virtual_network_rules: - list[~azure.mgmt.keyvault.v2021_06_01_preview.models.VirtualNetworkRule] - """ - super().__init__(**kwargs) - self.bypass = bypass - self.default_action = default_action - self.ip_rules = ip_rules - self.virtual_network_rules = virtual_network_rules - - -class Operation(_serialization.Model): - """Key Vault REST API operation definition. - - :ivar name: Operation name: {provider}/{resource}/{operation}. - :vartype name: str - :ivar display: Display metadata associated with the operation. - :vartype display: ~azure.mgmt.keyvault.v2021_06_01_preview.models.OperationDisplay - :ivar origin: The origin of operations. - :vartype origin: str - :ivar is_data_action: Property to specify whether the action is a data action. - :vartype is_data_action: bool - :ivar service_specification: One property of operation, include metric specifications. - :vartype service_specification: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.ServiceSpecification - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display": {"key": "display", "type": "OperationDisplay"}, - "origin": {"key": "origin", "type": "str"}, - "is_data_action": {"key": "isDataAction", "type": "bool"}, - "service_specification": {"key": "properties.serviceSpecification", "type": "ServiceSpecification"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display: Optional["_models.OperationDisplay"] = None, - origin: Optional[str] = None, - is_data_action: Optional[bool] = None, - service_specification: Optional["_models.ServiceSpecification"] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Operation name: {provider}/{resource}/{operation}. - :paramtype name: str - :keyword display: Display metadata associated with the operation. - :paramtype display: ~azure.mgmt.keyvault.v2021_06_01_preview.models.OperationDisplay - :keyword origin: The origin of operations. - :paramtype origin: str - :keyword is_data_action: Property to specify whether the action is a data action. - :paramtype is_data_action: bool - :keyword service_specification: One property of operation, include metric specifications. - :paramtype service_specification: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.ServiceSpecification - """ - super().__init__(**kwargs) - self.name = name - self.display = display - self.origin = origin - self.is_data_action = is_data_action - self.service_specification = service_specification - - -class OperationDisplay(_serialization.Model): - """Display metadata associated with the operation. - - :ivar provider: Service provider: Microsoft Key Vault. - :vartype provider: str - :ivar resource: Resource on which the operation is performed etc. - :vartype resource: str - :ivar operation: Type of operation: get, read, delete, etc. - :vartype operation: str - :ivar description: Description of operation. - :vartype description: str - """ - - _attribute_map = { - "provider": {"key": "provider", "type": "str"}, - "resource": {"key": "resource", "type": "str"}, - "operation": {"key": "operation", "type": "str"}, - "description": {"key": "description", "type": "str"}, - } - - def __init__( - self, - *, - provider: Optional[str] = None, - resource: Optional[str] = None, - operation: Optional[str] = None, - description: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword provider: Service provider: Microsoft Key Vault. - :paramtype provider: str - :keyword resource: Resource on which the operation is performed etc. - :paramtype resource: str - :keyword operation: Type of operation: get, read, delete, etc. - :paramtype operation: str - :keyword description: Description of operation. - :paramtype description: str - """ - super().__init__(**kwargs) - self.provider = provider - self.resource = resource - self.operation = operation - self.description = description - - -class OperationListResult(_serialization.Model): - """Result of the request to list Storage operations. It contains a list of operations and a URL - link to get the next set of results. - - :ivar value: List of Storage operations supported by the Storage resource provider. - :vartype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.Operation] - :ivar next_link: The URL to get the next set of operations. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Operation]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Operation"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: List of Storage operations supported by the Storage resource provider. - :paramtype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.Operation] - :keyword next_link: The URL to get the next set of operations. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class Permissions(_serialization.Model): - """Permissions the identity has for keys, secrets, certificates and storage. - - :ivar keys: Permissions to keys. - :vartype keys: list[str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyPermissions] - :ivar secrets: Permissions to secrets. - :vartype secrets: list[str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretPermissions] - :ivar certificates: Permissions to certificates. - :vartype certificates: list[str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.CertificatePermissions] - :ivar storage: Permissions to storage accounts. - :vartype storage: list[str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.StoragePermissions] - """ - - _attribute_map = { - "keys": {"key": "keys", "type": "[str]"}, - "secrets": {"key": "secrets", "type": "[str]"}, - "certificates": {"key": "certificates", "type": "[str]"}, - "storage": {"key": "storage", "type": "[str]"}, - } - - def __init__( - self, - *, - keys: Optional[List[Union[str, "_models.KeyPermissions"]]] = None, - secrets: Optional[List[Union[str, "_models.SecretPermissions"]]] = None, - certificates: Optional[List[Union[str, "_models.CertificatePermissions"]]] = None, - storage: Optional[List[Union[str, "_models.StoragePermissions"]]] = None, - **kwargs: Any - ) -> None: - """ - :keyword keys: Permissions to keys. - :paramtype keys: list[str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyPermissions] - :keyword secrets: Permissions to secrets. - :paramtype secrets: list[str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretPermissions] - :keyword certificates: Permissions to certificates. - :paramtype certificates: list[str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.CertificatePermissions] - :keyword storage: Permissions to storage accounts. - :paramtype storage: list[str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.StoragePermissions] - """ - super().__init__(**kwargs) - self.keys = keys - self.secrets = secrets - self.certificates = certificates - self.storage = storage - - -class PrivateEndpoint(_serialization.Model): - """Private endpoint object properties. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Full identifier of the private endpoint resource. - :vartype id: str - """ - - _validation = { - "id": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.id = None - - -class PrivateEndpointConnection(Resource): - """Private endpoint connection resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar etag: Modified whenever there is a change in the state of private endpoint connection. - :vartype etag: str - :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpoint - :ivar private_link_service_connection_state: Approval state of the private link connection. - :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateLinkServiceConnectionState - :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values - are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnectionProvisioningState - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "etag": {"key": "etag", "type": "str"}, - "private_endpoint": {"key": "properties.privateEndpoint", "type": "PrivateEndpoint"}, - "private_link_service_connection_state": { - "key": "properties.privateLinkServiceConnectionState", - "type": "PrivateLinkServiceConnectionState", - }, - "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - etag: Optional[str] = None, - private_endpoint: Optional["_models.PrivateEndpoint"] = None, - private_link_service_connection_state: Optional["_models.PrivateLinkServiceConnectionState"] = None, - provisioning_state: Optional[Union[str, "_models.PrivateEndpointConnectionProvisioningState"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword etag: Modified whenever there is a change in the state of private endpoint connection. - :paramtype etag: str - :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpoint - :keyword private_link_service_connection_state: Approval state of the private link connection. - :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateLinkServiceConnectionState - :keyword provisioning_state: Provisioning state of the private endpoint connection. Known - values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnectionProvisioningState - """ - super().__init__(**kwargs) - self.etag = etag - self.private_endpoint = private_endpoint - self.private_link_service_connection_state = private_link_service_connection_state - self.provisioning_state = provisioning_state - - -class PrivateEndpointConnectionItem(_serialization.Model): - """Private endpoint connection item. - - :ivar id: Id of private endpoint connection. - :vartype id: str - :ivar etag: Modified whenever there is a change in the state of private endpoint connection. - :vartype etag: str - :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpoint - :ivar private_link_service_connection_state: Approval state of the private link connection. - :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateLinkServiceConnectionState - :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values - are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnectionProvisioningState - """ - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "etag": {"key": "etag", "type": "str"}, - "private_endpoint": {"key": "properties.privateEndpoint", "type": "PrivateEndpoint"}, - "private_link_service_connection_state": { - "key": "properties.privateLinkServiceConnectionState", - "type": "PrivateLinkServiceConnectionState", - }, - "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - id: Optional[str] = None, # pylint: disable=redefined-builtin - etag: Optional[str] = None, - private_endpoint: Optional["_models.PrivateEndpoint"] = None, - private_link_service_connection_state: Optional["_models.PrivateLinkServiceConnectionState"] = None, - provisioning_state: Optional[Union[str, "_models.PrivateEndpointConnectionProvisioningState"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword id: Id of private endpoint connection. - :paramtype id: str - :keyword etag: Modified whenever there is a change in the state of private endpoint connection. - :paramtype etag: str - :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpoint - :keyword private_link_service_connection_state: Approval state of the private link connection. - :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateLinkServiceConnectionState - :keyword provisioning_state: Provisioning state of the private endpoint connection. Known - values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnectionProvisioningState - """ - super().__init__(**kwargs) - self.id = id - self.etag = etag - self.private_endpoint = private_endpoint - self.private_link_service_connection_state = private_link_service_connection_state - self.provisioning_state = provisioning_state - - -class PrivateEndpointConnectionListResult(_serialization.Model): - """List of private endpoint connections. - - :ivar value: The list of private endpoint connections. - :vartype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection] - :ivar next_link: The URL to get the next set of private endpoint connections. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[PrivateEndpointConnection]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, - *, - value: Optional[List["_models.PrivateEndpointConnection"]] = None, - next_link: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword value: The list of private endpoint connections. - :paramtype value: - list[~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection] - :keyword next_link: The URL to get the next set of private endpoint connections. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class PrivateLinkResource(Resource): - """A private link resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar group_id: Group identifier of private link resource. - :vartype group_id: str - :ivar required_members: Required member names of private link resource. - :vartype required_members: list[str] - :ivar required_zone_names: Required DNS zone names of the the private link resource. - :vartype required_zone_names: list[str] - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - "group_id": {"readonly": True}, - "required_members": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "group_id": {"key": "properties.groupId", "type": "str"}, - "required_members": {"key": "properties.requiredMembers", "type": "[str]"}, - "required_zone_names": {"key": "properties.requiredZoneNames", "type": "[str]"}, - } - - def __init__(self, *, required_zone_names: Optional[List[str]] = None, **kwargs: Any) -> None: - """ - :keyword required_zone_names: Required DNS zone names of the the private link resource. - :paramtype required_zone_names: list[str] - """ - super().__init__(**kwargs) - self.group_id = None - self.required_members = None - self.required_zone_names = required_zone_names - - -class PrivateLinkResourceListResult(_serialization.Model): - """A list of private link resources. - - :ivar value: Array of private link resources. - :vartype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateLinkResource] - """ - - _attribute_map = { - "value": {"key": "value", "type": "[PrivateLinkResource]"}, - } - - def __init__(self, *, value: Optional[List["_models.PrivateLinkResource"]] = None, **kwargs: Any) -> None: - """ - :keyword value: Array of private link resources. - :paramtype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateLinkResource] - """ - super().__init__(**kwargs) - self.value = value - - -class PrivateLinkServiceConnectionState(_serialization.Model): - """An object that represents the approval state of the private link connection. - - :ivar status: Indicates whether the connection has been approved, rejected or removed by the - key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :vartype status: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointServiceConnectionStatus - :ivar description: The reason for approval or rejection. - :vartype description: str - :ivar actions_required: A message indicating if changes on the service provider require any - updates on the consumer. "None" - :vartype actions_required: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.ActionsRequired - """ - - _attribute_map = { - "status": {"key": "status", "type": "str"}, - "description": {"key": "description", "type": "str"}, - "actions_required": {"key": "actionsRequired", "type": "str"}, - } - - def __init__( - self, - *, - status: Optional[Union[str, "_models.PrivateEndpointServiceConnectionStatus"]] = None, - description: Optional[str] = None, - actions_required: Optional[Union[str, "_models.ActionsRequired"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword status: Indicates whether the connection has been approved, rejected or removed by the - key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :paramtype status: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointServiceConnectionStatus - :keyword description: The reason for approval or rejection. - :paramtype description: str - :keyword actions_required: A message indicating if changes on the service provider require any - updates on the consumer. "None" - :paramtype actions_required: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.ActionsRequired - """ - super().__init__(**kwargs) - self.status = status - self.description = description - self.actions_required = actions_required - - -class ResourceListResult(_serialization.Model): - """List of vault resources. - - :ivar value: The list of vault resources. - :vartype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.Resource] - :ivar next_link: The URL to get the next set of vault resources. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Resource]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Resource"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of vault resources. - :paramtype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.Resource] - :keyword next_link: The URL to get the next set of vault resources. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class RotationPolicy(_serialization.Model): - """RotationPolicy. - - :ivar attributes: The attributes of key rotation policy. - :vartype attributes: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyRotationPolicyAttributes - :ivar lifetime_actions: The lifetimeActions for key rotation action. - :vartype lifetime_actions: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.LifetimeAction] - """ - - _attribute_map = { - "attributes": {"key": "attributes", "type": "KeyRotationPolicyAttributes"}, - "lifetime_actions": {"key": "lifetimeActions", "type": "[LifetimeAction]"}, - } - - def __init__( - self, - *, - attributes: Optional["_models.KeyRotationPolicyAttributes"] = None, - lifetime_actions: Optional[List["_models.LifetimeAction"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword attributes: The attributes of key rotation policy. - :paramtype attributes: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyRotationPolicyAttributes - :keyword lifetime_actions: The lifetimeActions for key rotation action. - :paramtype lifetime_actions: - list[~azure.mgmt.keyvault.v2021_06_01_preview.models.LifetimeAction] - """ - super().__init__(**kwargs) - self.attributes = attributes - self.lifetime_actions = lifetime_actions - - -class Secret(Resource): - """Resource information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar properties: Properties of the secret. Required. - :vartype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "SecretProperties"}, - } - - def __init__(self, *, properties: "_models.SecretProperties", **kwargs: Any) -> None: - """ - :keyword properties: Properties of the secret. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretProperties - """ - super().__init__(**kwargs) - self.properties = properties - - -class SecretAttributes(Attributes): - """The secret management attributes. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar enabled: Determines whether the object is enabled. - :vartype enabled: bool - :ivar not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :vartype not_before: ~datetime.datetime - :ivar expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :vartype expires: ~datetime.datetime - :ivar created: Creation time in seconds since 1970-01-01T00:00:00Z. - :vartype created: ~datetime.datetime - :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: ~datetime.datetime - """ - - -class SecretCreateOrUpdateParameters(_serialization.Model): - """Parameters for creating or updating a secret. - - All required parameters must be populated in order to send to server. - - :ivar tags: The tags that will be assigned to the secret. - :vartype tags: dict[str, str] - :ivar properties: Properties of the secret. Required. - :vartype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretProperties - """ - - _validation = { - "properties": {"required": True}, - } - - _attribute_map = { - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "SecretProperties"}, - } - - def __init__( - self, *, properties: "_models.SecretProperties", tags: Optional[Dict[str, str]] = None, **kwargs: Any - ) -> None: - """ - :keyword tags: The tags that will be assigned to the secret. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the secret. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretProperties - """ - super().__init__(**kwargs) - self.tags = tags - self.properties = properties - - -class SecretListResult(_serialization.Model): - """List of secrets. - - :ivar value: The list of secrets. - :vartype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret] - :ivar next_link: The URL to get the next set of secrets. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Secret]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Secret"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of secrets. - :paramtype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret] - :keyword next_link: The URL to get the next set of secrets. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class SecretPatchParameters(_serialization.Model): - """Parameters for patching a secret. - - :ivar tags: The tags that will be assigned to the secret. - :vartype tags: dict[str, str] - :ivar properties: Properties of the secret. - :vartype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretPatchProperties - """ - - _attribute_map = { - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "SecretPatchProperties"}, - } - - def __init__( - self, - *, - tags: Optional[Dict[str, str]] = None, - properties: Optional["_models.SecretPatchProperties"] = None, - **kwargs: Any - ) -> None: - """ - :keyword tags: The tags that will be assigned to the secret. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the secret. - :paramtype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretPatchProperties - """ - super().__init__(**kwargs) - self.tags = tags - self.properties = properties - - -class SecretPatchProperties(_serialization.Model): - """Properties of the secret. - - :ivar value: The value of the secret. - :vartype value: str - :ivar content_type: The content type of the secret. - :vartype content_type: str - :ivar attributes: The attributes of the secret. - :vartype attributes: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretAttributes - """ - - _attribute_map = { - "value": {"key": "value", "type": "str"}, - "content_type": {"key": "contentType", "type": "str"}, - "attributes": {"key": "attributes", "type": "SecretAttributes"}, - } - - def __init__( - self, - *, - value: Optional[str] = None, - content_type: Optional[str] = None, - attributes: Optional["_models.SecretAttributes"] = None, - **kwargs: Any - ) -> None: - """ - :keyword value: The value of the secret. - :paramtype value: str - :keyword content_type: The content type of the secret. - :paramtype content_type: str - :keyword attributes: The attributes of the secret. - :paramtype attributes: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretAttributes - """ - super().__init__(**kwargs) - self.value = value - self.content_type = content_type - self.attributes = attributes - - -class SecretProperties(_serialization.Model): - """Properties of the secret. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar value: The value of the secret. NOTE: 'value' will never be returned from the service, as - APIs using this model are is intended for internal use in ARM deployments. Users should use the - data-plane REST service for interaction with vault secrets. - :vartype value: str - :ivar content_type: The content type of the secret. - :vartype content_type: str - :ivar attributes: The attributes of the secret. - :vartype attributes: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretAttributes - :ivar secret_uri: The URI to retrieve the current version of the secret. - :vartype secret_uri: str - :ivar secret_uri_with_version: The URI to retrieve the specific version of the secret. - :vartype secret_uri_with_version: str - """ - - _validation = { - "secret_uri": {"readonly": True}, - "secret_uri_with_version": {"readonly": True}, - } - - _attribute_map = { - "value": {"key": "value", "type": "str"}, - "content_type": {"key": "contentType", "type": "str"}, - "attributes": {"key": "attributes", "type": "SecretAttributes"}, - "secret_uri": {"key": "secretUri", "type": "str"}, - "secret_uri_with_version": {"key": "secretUriWithVersion", "type": "str"}, - } - - def __init__( - self, - *, - value: Optional[str] = None, - content_type: Optional[str] = None, - attributes: Optional["_models.SecretAttributes"] = None, - **kwargs: Any - ) -> None: - """ - :keyword value: The value of the secret. NOTE: 'value' will never be returned from the service, - as APIs using this model are is intended for internal use in ARM deployments. Users should use - the data-plane REST service for interaction with vault secrets. - :paramtype value: str - :keyword content_type: The content type of the secret. - :paramtype content_type: str - :keyword attributes: The attributes of the secret. - :paramtype attributes: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretAttributes - """ - super().__init__(**kwargs) - self.value = value - self.content_type = content_type - self.attributes = attributes - self.secret_uri = None - self.secret_uri_with_version = None - - -class ServiceSpecification(_serialization.Model): - """One property of operation, include log specifications. - - :ivar log_specifications: Log specifications of operation. - :vartype log_specifications: - list[~azure.mgmt.keyvault.v2021_06_01_preview.models.LogSpecification] - :ivar metric_specifications: Metric specifications of operation. - :vartype metric_specifications: - list[~azure.mgmt.keyvault.v2021_06_01_preview.models.MetricSpecification] - """ - - _attribute_map = { - "log_specifications": {"key": "logSpecifications", "type": "[LogSpecification]"}, - "metric_specifications": {"key": "metricSpecifications", "type": "[MetricSpecification]"}, - } - - def __init__( - self, - *, - log_specifications: Optional[List["_models.LogSpecification"]] = None, - metric_specifications: Optional[List["_models.MetricSpecification"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword log_specifications: Log specifications of operation. - :paramtype log_specifications: - list[~azure.mgmt.keyvault.v2021_06_01_preview.models.LogSpecification] - :keyword metric_specifications: Metric specifications of operation. - :paramtype metric_specifications: - list[~azure.mgmt.keyvault.v2021_06_01_preview.models.MetricSpecification] - """ - super().__init__(**kwargs) - self.log_specifications = log_specifications - self.metric_specifications = metric_specifications - - -class Sku(_serialization.Model): - """SKU details. - - All required parameters must be populated in order to send to server. - - :ivar family: SKU family name. "A" - :vartype family: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.SkuFamily - :ivar name: SKU name to specify whether the key vault is a standard vault or a premium vault. - Required. Known values are: "standard" and "premium". - :vartype name: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.SkuName - """ - - _validation = { - "family": {"required": True}, - "name": {"required": True}, - } - - _attribute_map = { - "family": {"key": "family", "type": "str"}, - "name": {"key": "name", "type": "str"}, - } - - def __init__( - self, *, family: Union[str, "_models.SkuFamily"] = "A", name: Union[str, "_models.SkuName"], **kwargs: Any - ) -> None: - """ - :keyword family: SKU family name. "A" - :paramtype family: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.SkuFamily - :keyword name: SKU name to specify whether the key vault is a standard vault or a premium - vault. Required. Known values are: "standard" and "premium". - :paramtype name: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.SkuName - """ - super().__init__(**kwargs) - self.family = family - self.name = name - - -class SystemData(_serialization.Model): - """Metadata pertaining to creation and last modification of the key vault resource. - - :ivar created_by: The identity that created the key vault resource. - :vartype created_by: str - :ivar created_by_type: The type of identity that created the key vault resource. Known values - are: "User", "Application", "ManagedIdentity", and "Key". - :vartype created_by_type: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.IdentityType - :ivar created_at: The timestamp of the key vault resource creation (UTC). - :vartype created_at: ~datetime.datetime - :ivar last_modified_by: The identity that last modified the key vault resource. - :vartype last_modified_by: str - :ivar last_modified_by_type: The type of identity that last modified the key vault resource. - Known values are: "User", "Application", "ManagedIdentity", and "Key". - :vartype last_modified_by_type: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.IdentityType - :ivar last_modified_at: The timestamp of the key vault resource last modification (UTC). - :vartype last_modified_at: ~datetime.datetime - """ - - _attribute_map = { - "created_by": {"key": "createdBy", "type": "str"}, - "created_by_type": {"key": "createdByType", "type": "str"}, - "created_at": {"key": "createdAt", "type": "iso-8601"}, - "last_modified_by": {"key": "lastModifiedBy", "type": "str"}, - "last_modified_by_type": {"key": "lastModifiedByType", "type": "str"}, - "last_modified_at": {"key": "lastModifiedAt", "type": "iso-8601"}, - } - - def __init__( - self, - *, - created_by: Optional[str] = None, - created_by_type: Optional[Union[str, "_models.IdentityType"]] = None, - created_at: Optional[datetime.datetime] = None, - last_modified_by: Optional[str] = None, - last_modified_by_type: Optional[Union[str, "_models.IdentityType"]] = None, - last_modified_at: Optional[datetime.datetime] = None, - **kwargs: Any - ) -> None: - """ - :keyword created_by: The identity that created the key vault resource. - :paramtype created_by: str - :keyword created_by_type: The type of identity that created the key vault resource. Known - values are: "User", "Application", "ManagedIdentity", and "Key". - :paramtype created_by_type: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.IdentityType - :keyword created_at: The timestamp of the key vault resource creation (UTC). - :paramtype created_at: ~datetime.datetime - :keyword last_modified_by: The identity that last modified the key vault resource. - :paramtype last_modified_by: str - :keyword last_modified_by_type: The type of identity that last modified the key vault resource. - Known values are: "User", "Application", "ManagedIdentity", and "Key". - :paramtype last_modified_by_type: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.IdentityType - :keyword last_modified_at: The timestamp of the key vault resource last modification (UTC). - :paramtype last_modified_at: ~datetime.datetime - """ - super().__init__(**kwargs) - self.created_by = created_by - self.created_by_type = created_by_type - self.created_at = created_at - self.last_modified_by = last_modified_by - self.last_modified_by_type = last_modified_by_type - self.last_modified_at = last_modified_at - - -class Trigger(_serialization.Model): - """Trigger. - - :ivar time_after_create: The time duration after key creation to rotate the key. It only - applies to rotate. It will be in ISO 8601 duration format. Eg: 'P90D', 'P1Y'. - :vartype time_after_create: str - :ivar time_before_expiry: The time duration before key expiring to rotate or notify. It will be - in ISO 8601 duration format. Eg: 'P90D', 'P1Y'. - :vartype time_before_expiry: str - """ - - _attribute_map = { - "time_after_create": {"key": "timeAfterCreate", "type": "str"}, - "time_before_expiry": {"key": "timeBeforeExpiry", "type": "str"}, - } - - def __init__( - self, *, time_after_create: Optional[str] = None, time_before_expiry: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword time_after_create: The time duration after key creation to rotate the key. It only - applies to rotate. It will be in ISO 8601 duration format. Eg: 'P90D', 'P1Y'. - :paramtype time_after_create: str - :keyword time_before_expiry: The time duration before key expiring to rotate or notify. It will - be in ISO 8601 duration format. Eg: 'P90D', 'P1Y'. - :paramtype time_before_expiry: str - """ - super().__init__(**kwargs) - self.time_after_create = time_after_create - self.time_before_expiry = time_before_expiry - - -class Vault(_serialization.Model): - """Resource information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar system_data: System metadata for the key vault. - :vartype system_data: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SystemData - :ivar properties: Properties of the vault. Required. - :vartype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "system_data": {"readonly": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "system_data": {"key": "systemData", "type": "SystemData"}, - "properties": {"key": "properties", "type": "VaultProperties"}, - } - - def __init__( - self, - *, - properties: "_models.VaultProperties", - location: Optional[str] = None, - tags: Optional[Dict[str, str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: Azure location of the key vault resource. - :paramtype location: str - :keyword tags: Tags assigned to the key vault resource. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the vault. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = location - self.tags = tags - self.system_data = None - self.properties = properties - - -class VaultAccessPolicyParameters(_serialization.Model): - """Parameters for updating the access policy in a vault. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar id: The resource id of the access policy. - :vartype id: str - :ivar name: The resource name of the access policy. - :vartype name: str - :ivar type: The resource name of the access policy. - :vartype type: str - :ivar location: The resource type of the access policy. - :vartype location: str - :ivar properties: Properties of the access policy. Required. - :vartype properties: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultAccessPolicyProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "properties": {"key": "properties", "type": "VaultAccessPolicyProperties"}, - } - - def __init__(self, *, properties: "_models.VaultAccessPolicyProperties", **kwargs: Any) -> None: - """ - :keyword properties: Properties of the access policy. Required. - :paramtype properties: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultAccessPolicyProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = None - self.properties = properties - - -class VaultAccessPolicyProperties(_serialization.Model): - """Properties of the vault access policy. - - All required parameters must be populated in order to send to server. - - :ivar access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. Required. - :vartype access_policies: - list[~azure.mgmt.keyvault.v2021_06_01_preview.models.AccessPolicyEntry] - """ - - _validation = { - "access_policies": {"required": True}, - } - - _attribute_map = { - "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, - } - - def __init__(self, *, access_policies: List["_models.AccessPolicyEntry"], **kwargs: Any) -> None: - """ - :keyword access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. Required. - :paramtype access_policies: - list[~azure.mgmt.keyvault.v2021_06_01_preview.models.AccessPolicyEntry] - """ - super().__init__(**kwargs) - self.access_policies = access_policies - - -class VaultCheckNameAvailabilityParameters(_serialization.Model): - """The parameters used to check the availability of the vault name. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar name: The vault name. Required. - :vartype name: str - :ivar type: The type of resource, Microsoft.KeyVault/vaults. Required. Default value is - "Microsoft.KeyVault/vaults". - :vartype type: str - """ - - _validation = { - "name": {"required": True}, - "type": {"required": True, "constant": True}, - } - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - } - - type = "Microsoft.KeyVault/vaults" - - def __init__(self, *, name: str, **kwargs: Any) -> None: - """ - :keyword name: The vault name. Required. - :paramtype name: str - """ - super().__init__(**kwargs) - self.name = name - - -class VaultCreateOrUpdateParameters(_serialization.Model): - """Parameters for creating or updating a vault. - - All required parameters must be populated in order to send to server. - - :ivar location: The supported Azure location where the key vault should be created. Required. - :vartype location: str - :ivar tags: The tags that will be assigned to the key vault. - :vartype tags: dict[str, str] - :ivar properties: Properties of the vault. Required. - :vartype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultProperties - """ - - _validation = { - "location": {"required": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "VaultProperties"}, - } - - def __init__( - self, - *, - location: str, - properties: "_models.VaultProperties", - tags: Optional[Dict[str, str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the key vault should be created. - Required. - :paramtype location: str - :keyword tags: The tags that will be assigned to the key vault. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the vault. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultProperties - """ - super().__init__(**kwargs) - self.location = location - self.tags = tags - self.properties = properties - - -class VaultListResult(_serialization.Model): - """List of vaults. - - :ivar value: The list of vaults. - :vartype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault] - :ivar next_link: The URL to get the next set of vaults. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Vault]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Vault"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of vaults. - :paramtype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault] - :keyword next_link: The URL to get the next set of vaults. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class VaultPatchParameters(_serialization.Model): - """Parameters for creating or updating a vault. - - :ivar tags: The tags that will be assigned to the key vault. - :vartype tags: dict[str, str] - :ivar properties: Properties of the vault. - :vartype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultPatchProperties - """ - - _attribute_map = { - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "VaultPatchProperties"}, - } - - def __init__( - self, - *, - tags: Optional[Dict[str, str]] = None, - properties: Optional["_models.VaultPatchProperties"] = None, - **kwargs: Any - ) -> None: - """ - :keyword tags: The tags that will be assigned to the key vault. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the vault. - :paramtype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultPatchProperties - """ - super().__init__(**kwargs) - self.tags = tags - self.properties = properties - - -class VaultPatchProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Properties of the vault. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. - :vartype tenant_id: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Sku - :ivar access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. - :vartype access_policies: - list[~azure.mgmt.keyvault.v2021_06_01_preview.models.AccessPolicyEntry] - :ivar enabled_for_deployment: Property to specify whether Azure Virtual Machines are permitted - to retrieve certificates stored as secrets from the key vault. - :vartype enabled_for_deployment: bool - :ivar enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :vartype enabled_for_disk_encryption: bool - :ivar enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :vartype enabled_for_template_deployment: bool - :ivar enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. Once set to true, it cannot be reverted to false. - :vartype enable_soft_delete: bool - :ivar enable_rbac_authorization: Property that controls how data actions are authorized. When - true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored (warning: this - is a preview feature). When false, the key vault will use the access policies specified in - vault properties, and any policy stored on Azure Resource Manager will be ignored. If null or - not specified, the value of this property will not change. - :vartype enable_rbac_authorization: bool - :ivar soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and <=90. - :vartype soft_delete_retention_in_days: int - :ivar create_mode: The vault's create mode to indicate whether the vault need to be recovered - or not. Known values are: "recover" and "default". - :vartype create_mode: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.CreateMode - :ivar enable_purge_protection: Property specifying whether protection against purge is enabled - for this vault. Setting this property to true activates protection against purge for this vault - and its content - only the Key Vault service may initiate a hard, irrecoverable deletion. The - setting is effective only if soft delete is also enabled. Enabling this functionality is - irreversible - that is, the property does not accept false as its value. - :vartype enable_purge_protection: bool - :ivar network_acls: A collection of rules governing the accessibility of the vault from - specific network locations. - :vartype network_acls: ~azure.mgmt.keyvault.v2021_06_01_preview.models.NetworkRuleSet - :ivar public_network_access: Property to specify whether the vault will accept traffic from - public internet. If set to 'disabled' all traffic except private endpoint traffic and that that - originates from trusted services will be blocked. This will override the set firewall rules, - meaning that even if the firewall rules are present we will not honor the rules. - :vartype public_network_access: str - """ - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "sku": {"key": "sku", "type": "Sku"}, - "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, - "enabled_for_deployment": {"key": "enabledForDeployment", "type": "bool"}, - "enabled_for_disk_encryption": {"key": "enabledForDiskEncryption", "type": "bool"}, - "enabled_for_template_deployment": {"key": "enabledForTemplateDeployment", "type": "bool"}, - "enable_soft_delete": {"key": "enableSoftDelete", "type": "bool"}, - "enable_rbac_authorization": {"key": "enableRbacAuthorization", "type": "bool"}, - "soft_delete_retention_in_days": {"key": "softDeleteRetentionInDays", "type": "int"}, - "create_mode": {"key": "createMode", "type": "str"}, - "enable_purge_protection": {"key": "enablePurgeProtection", "type": "bool"}, - "network_acls": {"key": "networkAcls", "type": "NetworkRuleSet"}, - "public_network_access": {"key": "publicNetworkAccess", "type": "str"}, - } - - def __init__( - self, - *, - tenant_id: Optional[str] = None, - sku: Optional["_models.Sku"] = None, - access_policies: Optional[List["_models.AccessPolicyEntry"]] = None, - enabled_for_deployment: Optional[bool] = None, - enabled_for_disk_encryption: Optional[bool] = None, - enabled_for_template_deployment: Optional[bool] = None, - enable_soft_delete: Optional[bool] = None, - enable_rbac_authorization: Optional[bool] = None, - soft_delete_retention_in_days: Optional[int] = None, - create_mode: Optional[Union[str, "_models.CreateMode"]] = None, - enable_purge_protection: Optional[bool] = None, - network_acls: Optional["_models.NetworkRuleSet"] = None, - public_network_access: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. - :paramtype tenant_id: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Sku - :keyword access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. - :paramtype access_policies: - list[~azure.mgmt.keyvault.v2021_06_01_preview.models.AccessPolicyEntry] - :keyword enabled_for_deployment: Property to specify whether Azure Virtual Machines are - permitted to retrieve certificates stored as secrets from the key vault. - :paramtype enabled_for_deployment: bool - :keyword enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :paramtype enabled_for_disk_encryption: bool - :keyword enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :paramtype enabled_for_template_deployment: bool - :keyword enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. Once set to true, it cannot be reverted to false. - :paramtype enable_soft_delete: bool - :keyword enable_rbac_authorization: Property that controls how data actions are authorized. - When true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored (warning: this - is a preview feature). When false, the key vault will use the access policies specified in - vault properties, and any policy stored on Azure Resource Manager will be ignored. If null or - not specified, the value of this property will not change. - :paramtype enable_rbac_authorization: bool - :keyword soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and - <=90. - :paramtype soft_delete_retention_in_days: int - :keyword create_mode: The vault's create mode to indicate whether the vault need to be - recovered or not. Known values are: "recover" and "default". - :paramtype create_mode: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.CreateMode - :keyword enable_purge_protection: Property specifying whether protection against purge is - enabled for this vault. Setting this property to true activates protection against purge for - this vault and its content - only the Key Vault service may initiate a hard, irrecoverable - deletion. The setting is effective only if soft delete is also enabled. Enabling this - functionality is irreversible - that is, the property does not accept false as its value. - :paramtype enable_purge_protection: bool - :keyword network_acls: A collection of rules governing the accessibility of the vault from - specific network locations. - :paramtype network_acls: ~azure.mgmt.keyvault.v2021_06_01_preview.models.NetworkRuleSet - :keyword public_network_access: Property to specify whether the vault will accept traffic from - public internet. If set to 'disabled' all traffic except private endpoint traffic and that that - originates from trusted services will be blocked. This will override the set firewall rules, - meaning that even if the firewall rules are present we will not honor the rules. - :paramtype public_network_access: str - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.sku = sku - self.access_policies = access_policies - self.enabled_for_deployment = enabled_for_deployment - self.enabled_for_disk_encryption = enabled_for_disk_encryption - self.enabled_for_template_deployment = enabled_for_template_deployment - self.enable_soft_delete = enable_soft_delete - self.enable_rbac_authorization = enable_rbac_authorization - self.soft_delete_retention_in_days = soft_delete_retention_in_days - self.create_mode = create_mode - self.enable_purge_protection = enable_purge_protection - self.network_acls = network_acls - self.public_network_access = public_network_access - - -class VaultProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Properties of the vault. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :vartype tenant_id: str - :ivar sku: SKU details. Required. - :vartype sku: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Sku - :ivar access_policies: An array of 0 to 1024 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. When - ``createMode`` is set to ``recover``\\ , access policies are not required. Otherwise, access - policies are required. - :vartype access_policies: - list[~azure.mgmt.keyvault.v2021_06_01_preview.models.AccessPolicyEntry] - :ivar vault_uri: The URI of the vault for performing operations on keys and secrets. - :vartype vault_uri: str - :ivar hsm_pool_resource_id: The resource id of HSM Pool. - :vartype hsm_pool_resource_id: str - :ivar enabled_for_deployment: Property to specify whether Azure Virtual Machines are permitted - to retrieve certificates stored as secrets from the key vault. - :vartype enabled_for_deployment: bool - :ivar enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :vartype enabled_for_disk_encryption: bool - :ivar enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :vartype enabled_for_template_deployment: bool - :ivar enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. If it's not set to any value(true or false) when creating new key - vault, it will be set to true by default. Once set to true, it cannot be reverted to false. - :vartype enable_soft_delete: bool - :ivar soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and <=90. - :vartype soft_delete_retention_in_days: int - :ivar enable_rbac_authorization: Property that controls how data actions are authorized. When - true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored (warning: this - is a preview feature). When false, the key vault will use the access policies specified in - vault properties, and any policy stored on Azure Resource Manager will be ignored. If null or - not specified, the vault is created with the default value of false. Note that management - actions are always authorized with RBAC. - :vartype enable_rbac_authorization: bool - :ivar create_mode: The vault's create mode to indicate whether the vault need to be recovered - or not. Known values are: "recover" and "default". - :vartype create_mode: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.CreateMode - :ivar enable_purge_protection: Property specifying whether protection against purge is enabled - for this vault. Setting this property to true activates protection against purge for this vault - and its content - only the Key Vault service may initiate a hard, irrecoverable deletion. The - setting is effective only if soft delete is also enabled. Enabling this functionality is - irreversible - that is, the property does not accept false as its value. - :vartype enable_purge_protection: bool - :ivar network_acls: Rules governing the accessibility of the key vault from specific network - locations. - :vartype network_acls: ~azure.mgmt.keyvault.v2021_06_01_preview.models.NetworkRuleSet - :ivar provisioning_state: Provisioning state of the vault. Known values are: "Succeeded" and - "RegisteringDns". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultProvisioningState - :ivar private_endpoint_connections: List of private endpoint connections associated with the - key vault. - :vartype private_endpoint_connections: - list[~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnectionItem] - :ivar public_network_access: Property to specify whether the vault will accept traffic from - public internet. If set to 'disabled' all traffic except private endpoint traffic and that that - originates from trusted services will be blocked. This will override the set firewall rules, - meaning that even if the firewall rules are present we will not honor the rules. - :vartype public_network_access: str - """ - - _validation = { - "tenant_id": {"required": True}, - "sku": {"required": True}, - "hsm_pool_resource_id": {"readonly": True}, - "private_endpoint_connections": {"readonly": True}, - } - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "sku": {"key": "sku", "type": "Sku"}, - "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, - "vault_uri": {"key": "vaultUri", "type": "str"}, - "hsm_pool_resource_id": {"key": "hsmPoolResourceId", "type": "str"}, - "enabled_for_deployment": {"key": "enabledForDeployment", "type": "bool"}, - "enabled_for_disk_encryption": {"key": "enabledForDiskEncryption", "type": "bool"}, - "enabled_for_template_deployment": {"key": "enabledForTemplateDeployment", "type": "bool"}, - "enable_soft_delete": {"key": "enableSoftDelete", "type": "bool"}, - "soft_delete_retention_in_days": {"key": "softDeleteRetentionInDays", "type": "int"}, - "enable_rbac_authorization": {"key": "enableRbacAuthorization", "type": "bool"}, - "create_mode": {"key": "createMode", "type": "str"}, - "enable_purge_protection": {"key": "enablePurgeProtection", "type": "bool"}, - "network_acls": {"key": "networkAcls", "type": "NetworkRuleSet"}, - "provisioning_state": {"key": "provisioningState", "type": "str"}, - "private_endpoint_connections": { - "key": "privateEndpointConnections", - "type": "[PrivateEndpointConnectionItem]", - }, - "public_network_access": {"key": "publicNetworkAccess", "type": "str"}, - } - - def __init__( - self, - *, - tenant_id: str, - sku: "_models.Sku", - access_policies: Optional[List["_models.AccessPolicyEntry"]] = None, - vault_uri: Optional[str] = None, - enabled_for_deployment: Optional[bool] = None, - enabled_for_disk_encryption: Optional[bool] = None, - enabled_for_template_deployment: Optional[bool] = None, - enable_soft_delete: bool = True, - soft_delete_retention_in_days: int = 90, - enable_rbac_authorization: bool = False, - create_mode: Optional[Union[str, "_models.CreateMode"]] = None, - enable_purge_protection: Optional[bool] = None, - network_acls: Optional["_models.NetworkRuleSet"] = None, - provisioning_state: Optional[Union[str, "_models.VaultProvisioningState"]] = None, - public_network_access: str = "enabled", - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :paramtype tenant_id: str - :keyword sku: SKU details. Required. - :paramtype sku: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Sku - :keyword access_policies: An array of 0 to 1024 identities that have access to the key vault. - All identities in the array must use the same tenant ID as the key vault's tenant ID. When - ``createMode`` is set to ``recover``\\ , access policies are not required. Otherwise, access - policies are required. - :paramtype access_policies: - list[~azure.mgmt.keyvault.v2021_06_01_preview.models.AccessPolicyEntry] - :keyword vault_uri: The URI of the vault for performing operations on keys and secrets. - :paramtype vault_uri: str - :keyword enabled_for_deployment: Property to specify whether Azure Virtual Machines are - permitted to retrieve certificates stored as secrets from the key vault. - :paramtype enabled_for_deployment: bool - :keyword enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :paramtype enabled_for_disk_encryption: bool - :keyword enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :paramtype enabled_for_template_deployment: bool - :keyword enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. If it's not set to any value(true or false) when creating new key - vault, it will be set to true by default. Once set to true, it cannot be reverted to false. - :paramtype enable_soft_delete: bool - :keyword soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and - <=90. - :paramtype soft_delete_retention_in_days: int - :keyword enable_rbac_authorization: Property that controls how data actions are authorized. - When true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored (warning: this - is a preview feature). When false, the key vault will use the access policies specified in - vault properties, and any policy stored on Azure Resource Manager will be ignored. If null or - not specified, the vault is created with the default value of false. Note that management - actions are always authorized with RBAC. - :paramtype enable_rbac_authorization: bool - :keyword create_mode: The vault's create mode to indicate whether the vault need to be - recovered or not. Known values are: "recover" and "default". - :paramtype create_mode: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.CreateMode - :keyword enable_purge_protection: Property specifying whether protection against purge is - enabled for this vault. Setting this property to true activates protection against purge for - this vault and its content - only the Key Vault service may initiate a hard, irrecoverable - deletion. The setting is effective only if soft delete is also enabled. Enabling this - functionality is irreversible - that is, the property does not accept false as its value. - :paramtype enable_purge_protection: bool - :keyword network_acls: Rules governing the accessibility of the key vault from specific network - locations. - :paramtype network_acls: ~azure.mgmt.keyvault.v2021_06_01_preview.models.NetworkRuleSet - :keyword provisioning_state: Provisioning state of the vault. Known values are: "Succeeded" and - "RegisteringDns". - :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultProvisioningState - :keyword public_network_access: Property to specify whether the vault will accept traffic from - public internet. If set to 'disabled' all traffic except private endpoint traffic and that that - originates from trusted services will be blocked. This will override the set firewall rules, - meaning that even if the firewall rules are present we will not honor the rules. - :paramtype public_network_access: str - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.sku = sku - self.access_policies = access_policies - self.vault_uri = vault_uri - self.hsm_pool_resource_id = None - self.enabled_for_deployment = enabled_for_deployment - self.enabled_for_disk_encryption = enabled_for_disk_encryption - self.enabled_for_template_deployment = enabled_for_template_deployment - self.enable_soft_delete = enable_soft_delete - self.soft_delete_retention_in_days = soft_delete_retention_in_days - self.enable_rbac_authorization = enable_rbac_authorization - self.create_mode = create_mode - self.enable_purge_protection = enable_purge_protection - self.network_acls = network_acls - self.provisioning_state = provisioning_state - self.private_endpoint_connections = None - self.public_network_access = public_network_access - - -class VirtualNetworkRule(_serialization.Model): - """A rule governing the accessibility of a vault from a specific virtual network. - - All required parameters must be populated in order to send to server. - - :ivar id: Full resource id of a vnet subnet, such as - '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. - Required. - :vartype id: str - :ivar ignore_missing_vnet_service_endpoint: Property to specify whether NRP will ignore the - check if parent subnet has serviceEndpoints configured. - :vartype ignore_missing_vnet_service_endpoint: bool - """ - - _validation = { - "id": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "ignore_missing_vnet_service_endpoint": {"key": "ignoreMissingVnetServiceEndpoint", "type": "bool"}, - } - - def __init__( - self, - *, - id: str, # pylint: disable=redefined-builtin - ignore_missing_vnet_service_endpoint: Optional[bool] = None, - **kwargs: Any - ) -> None: - """ - :keyword id: Full resource id of a vnet subnet, such as - '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. # pylint: disable=line-too-long - Required. - :paramtype id: str - :keyword ignore_missing_vnet_service_endpoint: Property to specify whether NRP will ignore the - check if parent subnet has serviceEndpoints configured. - :paramtype ignore_missing_vnet_service_endpoint: bool - """ - super().__init__(**kwargs) - self.id = id - self.ignore_missing_vnet_service_endpoint = ignore_missing_vnet_service_endpoint diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/models/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/models/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/models/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/__init__.py deleted file mode 100644 index 224be3f73e55..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/__init__.py +++ /dev/null @@ -1,35 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._keys_operations import KeysOperations -from ._vaults_operations import VaultsOperations -from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations -from ._private_link_resources_operations import PrivateLinkResourcesOperations -from ._managed_hsms_operations import ManagedHsmsOperations -from ._mhsm_private_endpoint_connections_operations import MHSMPrivateEndpointConnectionsOperations -from ._mhsm_private_link_resources_operations import MHSMPrivateLinkResourcesOperations -from ._operations import Operations -from ._secrets_operations import SecretsOperations - -from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "KeysOperations", - "VaultsOperations", - "PrivateEndpointConnectionsOperations", - "PrivateLinkResourcesOperations", - "ManagedHsmsOperations", - "MHSMPrivateEndpointConnectionsOperations", - "MHSMPrivateLinkResourcesOperations", - "Operations", - "SecretsOperations", -] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_keys_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_keys_operations.py deleted file mode 100644 index f6c4ad85128e..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_keys_operations.py +++ /dev/null @@ -1,669 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Optional, Type, TypeVar, Union, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_if_not_exist_request( - resource_group_name: str, vault_name: str, key_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "keyName": _SERIALIZER.url("key_name", key_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request( - resource_group_name: str, vault_name: str, key_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "keyName": _SERIALIZER.url("key_name", key_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_version_request( - resource_group_name: str, vault_name: str, key_name: str, key_version: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "keyName": _SERIALIZER.url("key_name", key_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - "keyVersion": _SERIALIZER.url("key_version", key_version, "str", pattern=r"^[a-fA-F0-9]{32}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_versions_request( - resource_group_name: str, vault_name: str, key_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "keyName": _SERIALIZER.url("key_name", key_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class KeysOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_06_01_preview.KeyVaultManagementClient`'s - :attr:`keys` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @overload - def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: _models.KeyCreateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyCreateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: Union[_models.KeyCreateParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Is either a - KeyCreateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyCreateParameters or - IO[bytes] - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "KeyCreateParameters") - - _request = build_create_if_not_exist_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def get(self, resource_group_name: str, vault_name: str, key_name: str, **kwargs: Any) -> _models.Key: - """Gets the current version of the specified key from the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key to be retrieved. Required. - :type vault_name: str - :param key_name: The name of the key to be retrieved. Required. - :type key_name: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> Iterable["_models.Key"]: - """Lists the keys in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the keys to be retrieved. Required. - :type vault_name: str - :return: An iterator like instance of either Key or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.Key] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("KeyListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def get_version( - self, resource_group_name: str, vault_name: str, key_name: str, key_version: str, **kwargs: Any - ) -> _models.Key: - """Gets the specified version of the specified key in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key version to be retrieved. - Required. - :type vault_name: str - :param key_name: The name of the key version to be retrieved. Required. - :type key_name: str - :param key_version: The version of the key to be retrieved. Required. - :type key_version: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - _request = build_get_version_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - key_version=key_version, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_versions( - self, resource_group_name: str, vault_name: str, key_name: str, **kwargs: Any - ) -> Iterable["_models.Key"]: - """Lists the versions of the specified key in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key versions to be retrieved. - Required. - :type vault_name: str - :param key_name: The name of the key versions to be retrieved. Required. - :type key_name: str - :return: An iterator like instance of either Key or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.Key] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_versions_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("KeyListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_managed_hsms_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_managed_hsms_operations.py deleted file mode 100644 index abcecea18485..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_managed_hsms_operations.py +++ /dev/null @@ -1,1292 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_or_update_request( - resource_group_name: str, name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_request(resource_group_name: str, name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request(resource_group_name: str, name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request(resource_group_name: str, name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_resource_group_request( - resource_group_name: str, subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_subscription_request( - subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_deleted_request(subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedManagedHSMs") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_deleted_request(name: str, location: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "name": _SERIALIZER.url("name", name, "str"), - "location": _SERIALIZER.url("location", location, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_purge_deleted_request(name: str, location: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge", - ) # pylint: disable=line-too-long - path_format_arguments = { - "name": _SERIALIZER.url("name", name, "str"), - "location": _SERIALIZER.url("location", location, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -class ManagedHsmsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_06_01_preview.KeyVaultManagementClient`'s - :attr:`managed_hsms` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - def _create_or_update_initial( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "ManagedHsm") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def begin_create_or_update( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Is either a ManagedHsm - type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm or IO[bytes] - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._create_or_update_initial( - resource_group_name=resource_group_name, - name=name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.ManagedHsm].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.ManagedHsm]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - def _update_initial( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "ManagedHsm") - - _request = build_update_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @overload - def begin_update( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_update( - self, - resource_group_name: str, - name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def begin_update( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Is either a ManagedHsm type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm or IO[bytes] - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._update_initial( - resource_group_name=resource_group_name, - name=name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.ManagedHsm].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.ManagedHsm]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - def _delete_initial(self, resource_group_name: str, name: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_delete(self, resource_group_name: str, name: str, **kwargs: Any) -> LROPoller[None]: - """Deletes the specified managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: The name of the managed HSM Pool to delete. Required. - :type name: str - :return: An instance of LROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._delete_initial( - resource_group_name=resource_group_name, - name=name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def get(self, resource_group_name: str, name: str, **kwargs: Any) -> Optional[_models.ManagedHsm]: - """Gets the specified managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: The name of the managed HSM Pool. Required. - :type name: str - :return: ManagedHsm or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm or None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[Optional[_models.ManagedHsm]] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> Iterable["_models.ManagedHsm"]: - """The List operation gets information about the managed HSM Pools associated with the - subscription and within the specified resource group. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.ManagedHsm"]: - """The List operation gets information about the managed HSM Pools associated with the - subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedManagedHsm"]: - """The List operation gets information about the deleted managed HSMs associated with the - subscription. - - :return: An iterator like instance of either DeletedManagedHsm or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletedManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.DeletedManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("DeletedManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def get_deleted(self, name: str, location: str, **kwargs: Any) -> _models.DeletedManagedHsm: - """Gets the specified deleted managed HSM. - - :param name: The name of the deleted managed HSM. Required. - :type name: str - :param location: The location of the deleted managed HSM. Required. - :type location: str - :return: DeletedManagedHsm or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletedManagedHsm - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.DeletedManagedHsm] = kwargs.pop("cls", None) - - _request = build_get_deleted_request( - name=name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = self._deserialize("DeletedManagedHsm", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_purge_deleted_request( - name=name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_purge_deleted(self, name: str, location: str, **kwargs: Any) -> LROPoller[None]: - """Permanently deletes the specified managed HSM. - - :param name: The name of the soft-deleted managed HSM. Required. - :type name: str - :param location: The location of the soft-deleted managed HSM. Required. - :type location: str - :return: An instance of LROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._purge_deleted_initial( - name=name, - location=location, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_mhsm_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_mhsm_private_endpoint_connections_operations.py deleted file mode 100644 index 00024e43b0cf..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_mhsm_private_endpoint_connections_operations.py +++ /dev/null @@ -1,631 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_by_resource_request( - resource_group_name: str, name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request( - resource_group_name: str, name: str, private_endpoint_connection_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_put_request( - resource_group_name: str, name: str, private_endpoint_connection_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request( - resource_group_name: str, name: str, private_endpoint_connection_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -class MHSMPrivateEndpointConnectionsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_06_01_preview.KeyVaultManagementClient`'s - :attr:`mhsm_private_endpoint_connections` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list_by_resource( - self, resource_group_name: str, name: str, **kwargs: Any - ) -> Iterable["_models.MHSMPrivateEndpointConnection"]: - """The List operation gets information about the private endpoint connections associated with the - managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :return: An iterator like instance of either MHSMPrivateEndpointConnection or the result of - cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("MHSMPrivateEndpointConnectionsListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def get( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Gets the specified private endpoint connection associated with the managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: _models.MHSMPrivateEndpointConnection, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: Union[_models.MHSMPrivateEndpointConnection, IO[bytes]], - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Is either a - MHSMPrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection - or IO[bytes] - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _json = self._serialize.body(properties, "MHSMPrivateEndpointConnection") - - _request = build_put_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Azure-AsyncOperation"] = self._deserialize( - "str", response.headers.get("Azure-AsyncOperation") - ) - - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - def _delete_initial( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_delete( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> LROPoller[_models.MHSMPrivateEndpointConnection]: - """Deletes the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :return: An instance of LROPoller that returns either MHSMPrivateEndpointConnection or the - result of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._delete_initial( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.MHSMPrivateEndpointConnection].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.MHSMPrivateEndpointConnection]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_mhsm_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_mhsm_private_link_resources_operations.py deleted file mode 100644 index 54cee2af8845..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_mhsm_private_link_resources_operations.py +++ /dev/null @@ -1,148 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_by_mhsm_resource_request( - resource_group_name: str, name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateLinkResources", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class MHSMPrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_06_01_preview.KeyVaultManagementClient`'s - :attr:`mhsm_private_link_resources` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list_by_mhsm_resource( - self, resource_group_name: str, name: str, **kwargs: Any - ) -> _models.MHSMPrivateLinkResourceListResult: - """Gets the private link resources supported for the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :return: MHSMPrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateLinkResourceListResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.MHSMPrivateLinkResourceListResult] = kwargs.pop("cls", None) - - _request = build_list_by_mhsm_resource_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("MHSMPrivateLinkResourceListResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_operations.py deleted file mode 100644 index c65db3a6d7b4..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_operations.py +++ /dev/null @@ -1,154 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Iterable, Optional, Type, TypeVar -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_request(**kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/providers/Microsoft.KeyVault/operations") - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class Operations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_06_01_preview.KeyVaultManagementClient`'s - :attr:`operations` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: - """Lists all of the available Key Vault Rest API operations. - - :return: An iterator like instance of either Operation or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.Operation] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("OperationListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_patch.py deleted file mode 100644 index 133abf6d2e10..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_patch.py +++ /dev/null @@ -1,134 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -import sys -from typing import Any, List, Iterable, Optional, Type -import urllib.parse - -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.rest import HttpRequest -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ._vaults_operations import VaultsOperations as _VaultsOperations, ClsType, build_list_request -from .. import models as _models - -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports - -class VaultsOperations(_VaultsOperations): - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - -__all__: List[str] = ["VaultsOperations"] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_private_endpoint_connections_operations.py deleted file mode 100644 index cf25d184b920..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_private_endpoint_connections_operations.py +++ /dev/null @@ -1,637 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_get_request( - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_put_request( - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request( - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_resource_request( - resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class PrivateEndpointConnectionsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_06_01_preview.KeyVaultManagementClient`'s - :attr:`private_endpoint_connections` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def get( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Optional[_models.PrivateEndpointConnection]: - """Gets the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: PrivateEndpointConnection or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection or None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[Optional[_models.PrivateEndpointConnection]] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: _models.PrivateEndpointConnection, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: Union[_models.PrivateEndpointConnection, IO[bytes]], - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Is either a - PrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection or - IO[bytes] - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _json = self._serialize.body(properties, "PrivateEndpointConnection") - - _request = build_put_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Azure-AsyncOperation"] = self._deserialize( - "str", response.headers.get("Azure-AsyncOperation") - ) - - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - def _delete_initial( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_delete( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> LROPoller[_models.PrivateEndpointConnection]: - """Deletes the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: An instance of LROPoller that returns either PrivateEndpointConnection or the result - of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._delete_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.PrivateEndpointConnection].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.PrivateEndpointConnection]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @distributed_trace - def list_by_resource( - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> Iterable["_models.PrivateEndpointConnection"]: - """The List operation gets information about the private endpoint connections associated with the - vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :return: An iterator like instance of either PrivateEndpointConnection or the result of - cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.PrivateEndpointConnectionListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("PrivateEndpointConnectionListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_private_link_resources_operations.py deleted file mode 100644 index f7fdb7e0eac5..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_private_link_resources_operations.py +++ /dev/null @@ -1,147 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_by_vault_request( - resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class PrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_06_01_preview.KeyVaultManagementClient`'s - :attr:`private_link_resources` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list_by_vault( - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> _models.PrivateLinkResourceListResult: - """Gets the private link resources supported for the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :return: PrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateLinkResourceListResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.PrivateLinkResourceListResult] = kwargs.pop("cls", None) - - _request = build_list_by_vault_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_secrets_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_secrets_operations.py deleted file mode 100644 index 16ce75faa4d5..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_secrets_operations.py +++ /dev/null @@ -1,654 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Optional, Type, TypeVar, Union, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_or_update_request( - resource_group_name: str, vault_name: str, secret_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "secretName": _SERIALIZER.url("secret_name", secret_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_request( - resource_group_name: str, vault_name: str, secret_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "secretName": _SERIALIZER.url("secret_name", secret_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request( - resource_group_name: str, vault_name: str, secret_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "secretName": _SERIALIZER.url("secret_name", secret_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_request( - resource_group_name: str, vault_name: str, subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class SecretsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_06_01_preview.KeyVaultManagementClient`'s - :attr:`secrets` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @overload - def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: _models.SecretCreateOrUpdateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Required. - :type parameters: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretCreateOrUpdateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: Union[_models.SecretCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Is either a - SecretCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretCreateOrUpdateParameters or IO[bytes] - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "SecretCreateOrUpdateParameters") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: _models.SecretPatchParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretPatchParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: Union[_models.SecretPatchParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Is either a SecretPatchParameters type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretPatchParameters or - IO[bytes] - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "SecretPatchParameters") - - _request = build_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def get(self, resource_group_name: str, vault_name: str, secret_name: str, **kwargs: Any) -> _models.Secret: - """Gets the specified secret. NOTE: This API is intended for internal use in ARM deployments. - Users should use the data-plane REST service for interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param secret_name: The name of the secret. Required. - :type secret_name: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list( - self, resource_group_name: str, vault_name: str, top: Optional[int] = None, **kwargs: Any - ) -> Iterable["_models.Secret"]: - """The List operation gets information about the secrets in a vault. NOTE: This API is intended - for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Secret or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.SecretListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("SecretListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_vaults_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_vaults_operations.py deleted file mode 100644 index e636cb6a7169..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/operations/_vaults_operations.py +++ /dev/null @@ -1,1614 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Literal, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_or_update_request( - resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_access_policy_request( - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "operationKind": _SERIALIZER.url("operation_kind", operation_kind, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_resource_group_request( - resource_group_name: str, subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_subscription_request( - subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_deleted_request(subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_deleted_request(vault_name: str, location: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "location": _SERIALIZER.url("location", location, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_purge_deleted_request(vault_name: str, location: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge", - ) # pylint: disable=line-too-long - path_format_arguments = { - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "location": _SERIALIZER.url("location", location, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_request(subscription_id: str, *, top: Optional[int] = None, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop("api_version", _params.pop("api-version", "2015-11-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resources") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["$filter"] = _SERIALIZER.query("filter", filter, "str") - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_check_name_availability_request(subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability" - ) - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -class VaultsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_06_01_preview.KeyVaultManagementClient`'s - :attr:`vaults` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - def _create_or_update_initial( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 201: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultCreateOrUpdateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> LROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Is either a - VaultCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultCreateOrUpdateParameters - or IO[bytes] - :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._create_or_update_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("Vault", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.Vault].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.Vault]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @overload - def update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultPatchParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultPatchParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultPatchParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Is either a VaultPatchParameters type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultPatchParameters or - IO[bytes] - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultPatchParameters") - - _request = build_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def delete( # pylint: disable=inconsistent-return-statements - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> None: - """Deletes the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault to delete. Required. - :type vault_name: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - @distributed_trace - def get(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> _models.Vault: - """Gets the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: _models.VaultAccessPolicyParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultAccessPolicyParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: Union[_models.VaultAccessPolicyParameters, IO[bytes]], - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or - ~azure.mgmt.keyvault.v2021_06_01_preview.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Is either a - VaultAccessPolicyParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultAccessPolicyParameters - or IO[bytes] - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.VaultAccessPolicyParameters] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") - - _request = build_update_access_policy_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - operation_kind=operation_kind, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> Iterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription and - within the specified resource group. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedVault"]: - """Gets information about the deleted vaults in a subscription. - - :return: An iterator like instance of either DeletedVault or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletedVault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.DeletedVaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("DeletedVaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _models.DeletedVault: - """Gets the deleted Azure key vault. - - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param location: The location of the deleted vault. Required. - :type location: str - :return: DeletedVault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletedVault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[_models.DeletedVault] = kwargs.pop("cls", None) - - _request = build_get_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("DeletedVault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_purge_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_purge_deleted(self, vault_name: str, location: str, **kwargs: Any) -> LROPoller[None]: - """Permanently deletes the specified vault. aka Purges the deleted Azure key vault. - - :param vault_name: The name of the soft-deleted vault. Required. - :type vault_name: str - :param location: The location of the soft-deleted vault. Required. - :type location: str - :return: An instance of LROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._purge_deleted_initial( - vault_name=vault_name, - location=location, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @overload - def check_name_availability( - self, - vault_name: _models.VaultCheckNameAvailabilityParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultCheckNameAvailabilityParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def check_name_availability( - self, vault_name: IO[bytes], *, content_type: str = "application/json", **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def check_name_availability( - self, vault_name: Union[_models.VaultCheckNameAvailabilityParameters, IO[bytes]], **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Is either a VaultCheckNameAvailabilityParameters type - or a IO[bytes] type. Required. - :type vault_name: - ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultCheckNameAvailabilityParameters or - IO[bytes] - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2021-06-01-preview") - ) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.CheckNameAvailabilityResult] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(vault_name, (IOBase, bytes)): - _content = vault_name - else: - _json = self._serialize.body(vault_name, "VaultCheckNameAvailabilityParameters") - - _request = build_check_name_availability_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/py.typed b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/py.typed deleted file mode 100644 index e5aff4f83af8..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/py.typed +++ /dev/null @@ -1 +0,0 @@ -# Marker file for PEP 561. \ No newline at end of file diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/__init__.py deleted file mode 100644 index 6bb4b7c63a45..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/__init__.py +++ /dev/null @@ -1,26 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._key_vault_management_client import KeyVaultManagementClient -from ._version import VERSION - -__version__ = VERSION - -try: - from ._patch import __all__ as _patch_all - from ._patch import * # pylint: disable=unused-wildcard-import -except ImportError: - _patch_all = [] -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "KeyVaultManagementClient", -] -__all__.extend([p for p in _patch_all if p not in __all__]) - -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/_key_vault_management_client.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/_key_vault_management_client.py deleted file mode 100644 index 79f944d9a3c5..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/_key_vault_management_client.py +++ /dev/null @@ -1,162 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from copy import deepcopy -from typing import Any, TYPE_CHECKING -from typing_extensions import Self - -from azure.core.pipeline import policies -from azure.core.rest import HttpRequest, HttpResponse -from azure.mgmt.core import ARMPipelineClient -from azure.mgmt.core.policies import ARMAutoResourceProviderRegistrationPolicy - -from . import models as _models -from .._serialization import Deserializer, Serializer -from ._configuration import KeyVaultManagementClientConfiguration -from .operations import ( - KeysOperations, - MHSMPrivateEndpointConnectionsOperations, - MHSMPrivateLinkResourcesOperations, - ManagedHsmsOperations, - Operations, - PrivateEndpointConnectionsOperations, - PrivateLinkResourcesOperations, - SecretsOperations, - VaultsOperations, -) - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials import TokenCredential - - -class KeyVaultManagementClient: # pylint: disable=client-accepts-api-version-keyword,too-many-instance-attributes - """The Azure management API provides a RESTful set of web services that interact with Azure Key - Vault. - - :ivar keys: KeysOperations operations - :vartype keys: azure.mgmt.keyvault.v2021_10_01.operations.KeysOperations - :ivar vaults: VaultsOperations operations - :vartype vaults: azure.mgmt.keyvault.v2021_10_01.operations.VaultsOperations - :ivar private_endpoint_connections: PrivateEndpointConnectionsOperations operations - :vartype private_endpoint_connections: - azure.mgmt.keyvault.v2021_10_01.operations.PrivateEndpointConnectionsOperations - :ivar private_link_resources: PrivateLinkResourcesOperations operations - :vartype private_link_resources: - azure.mgmt.keyvault.v2021_10_01.operations.PrivateLinkResourcesOperations - :ivar managed_hsms: ManagedHsmsOperations operations - :vartype managed_hsms: azure.mgmt.keyvault.v2021_10_01.operations.ManagedHsmsOperations - :ivar mhsm_private_endpoint_connections: MHSMPrivateEndpointConnectionsOperations operations - :vartype mhsm_private_endpoint_connections: - azure.mgmt.keyvault.v2021_10_01.operations.MHSMPrivateEndpointConnectionsOperations - :ivar mhsm_private_link_resources: MHSMPrivateLinkResourcesOperations operations - :vartype mhsm_private_link_resources: - azure.mgmt.keyvault.v2021_10_01.operations.MHSMPrivateLinkResourcesOperations - :ivar operations: Operations operations - :vartype operations: azure.mgmt.keyvault.v2021_10_01.operations.Operations - :ivar secrets: SecretsOperations operations - :vartype secrets: azure.mgmt.keyvault.v2021_10_01.operations.SecretsOperations - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials.TokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :param base_url: Service URL. Default value is "https://management.azure.com". - :type base_url: str - :keyword api_version: Api Version. Default value is "2021-10-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. - """ - - def __init__( - self, - credential: "TokenCredential", - subscription_id: str, - base_url: str = "https://management.azure.com", - **kwargs: Any - ) -> None: - self._config = KeyVaultManagementClientConfiguration( - credential=credential, subscription_id=subscription_id, **kwargs - ) - _policies = kwargs.pop("policies", None) - if _policies is None: - _policies = [ - policies.RequestIdPolicy(**kwargs), - self._config.headers_policy, - self._config.user_agent_policy, - self._config.proxy_policy, - policies.ContentDecodePolicy(**kwargs), - ARMAutoResourceProviderRegistrationPolicy(), - self._config.redirect_policy, - self._config.retry_policy, - self._config.authentication_policy, - self._config.custom_hook_policy, - self._config.logging_policy, - policies.DistributedTracingPolicy(**kwargs), - policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, - self._config.http_logging_policy, - ] - self._client: ARMPipelineClient = ARMPipelineClient(base_url=base_url, policies=_policies, **kwargs) - - client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} - self._serialize = Serializer(client_models) - self._deserialize = Deserializer(client_models) - self._serialize.client_side_validation = False - self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize, "2021-10-01") - self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize, "2021-10-01") - self.private_endpoint_connections = PrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-10-01" - ) - self.private_link_resources = PrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-10-01" - ) - self.managed_hsms = ManagedHsmsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-10-01" - ) - self.mhsm_private_endpoint_connections = MHSMPrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-10-01" - ) - self.mhsm_private_link_resources = MHSMPrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-10-01" - ) - self.operations = Operations(self._client, self._config, self._serialize, self._deserialize, "2021-10-01") - self.secrets = SecretsOperations(self._client, self._config, self._serialize, self._deserialize, "2021-10-01") - - def _send_request(self, request: HttpRequest, *, stream: bool = False, **kwargs: Any) -> HttpResponse: - """Runs the network request through the client's chained policies. - - >>> from azure.core.rest import HttpRequest - >>> request = HttpRequest("GET", "https://www.example.org/") - - >>> response = client._send_request(request) - - - For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request - - :param request: The network request you want to make. Required. - :type request: ~azure.core.rest.HttpRequest - :keyword bool stream: Whether the response payload will be streamed. Defaults to False. - :return: The response of your network call. Does not do error handling on your response. - :rtype: ~azure.core.rest.HttpResponse - """ - - request_copy = deepcopy(request) - request_copy.url = self._client.format_url(request_copy.url) - return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore - - def close(self) -> None: - self._client.close() - - def __enter__(self) -> Self: - self._client.__enter__() - return self - - def __exit__(self, *exc_details: Any) -> None: - self._client.__exit__(*exc_details) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/_metadata.json b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/_metadata.json deleted file mode 100644 index a2e795b4a29b..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/_metadata.json +++ /dev/null @@ -1,118 +0,0 @@ -{ - "chosen_version": "2021-10-01", - "total_api_version_list": ["2021-10-01"], - "client": { - "name": "KeyVaultManagementClient", - "filename": "_key_vault_management_client", - "description": "The Azure management API provides a RESTful set of web services that interact with Azure Key Vault.", - "host_value": "\"https://management.azure.com\"", - "parameterized_host_template": null, - "azure_arm": true, - "has_public_lro_operations": true, - "client_side_validation": false, - "sync_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"sdkcore\": {\"azure.mgmt.core\": [\"ARMPipelineClient\"], \"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"ARMAutoResourceProviderRegistrationPolicy\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \".._serialization\": [\"Deserializer\", \"Serializer\"]}, \"stdlib\": {\"typing_extensions\": [\"Self\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}}", - "async_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"sdkcore\": {\"azure.mgmt.core\": [\"AsyncARMPipelineClient\"], \"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"AsyncARMAutoResourceProviderRegistrationPolicy\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \"..._serialization\": [\"Deserializer\", \"Serializer\"]}, \"stdlib\": {\"typing_extensions\": [\"Self\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"]}}}" - }, - "global_parameters": { - "sync": { - "credential": { - "signature": "credential: \"TokenCredential\",", - "description": "Credential needed for the client to connect to Azure. Required.", - "docstring_type": "~azure.core.credentials.TokenCredential", - "required": true, - "method_location": "positional" - }, - "subscription_id": { - "signature": "subscription_id: str,", - "description": "Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. Required.", - "docstring_type": "str", - "required": true, - "method_location": "positional" - } - }, - "async": { - "credential": { - "signature": "credential: \"AsyncTokenCredential\",", - "description": "Credential needed for the client to connect to Azure. Required.", - "docstring_type": "~azure.core.credentials_async.AsyncTokenCredential", - "required": true - }, - "subscription_id": { - "signature": "subscription_id: str,", - "description": "Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. Required.", - "docstring_type": "str", - "required": true - } - }, - "constant": { - }, - "call": "credential, subscription_id", - "service_client_specific": { - "sync": { - "api_version": { - "signature": "api_version: Optional[str]=None,", - "description": "API version to use if no profile is provided, or if missing in profile.", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "base_url": { - "signature": "base_url: str = \"https://management.azure.com\",", - "description": "Service URL", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "profile": { - "signature": "profile: KnownProfiles=KnownProfiles.default,", - "description": "A profile definition, from KnownProfiles to dict.", - "docstring_type": "azure.profiles.KnownProfiles", - "required": false, - "method_location": "positional" - } - }, - "async": { - "api_version": { - "signature": "api_version: Optional[str] = None,", - "description": "API version to use if no profile is provided, or if missing in profile.", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "base_url": { - "signature": "base_url: str = \"https://management.azure.com\",", - "description": "Service URL", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "profile": { - "signature": "profile: KnownProfiles = KnownProfiles.default,", - "description": "A profile definition, from KnownProfiles to dict.", - "docstring_type": "azure.profiles.KnownProfiles", - "required": false, - "method_location": "positional" - } - } - } - }, - "config": { - "credential": true, - "credential_scopes": ["https://management.azure.com/.default"], - "credential_call_sync": "ARMChallengeAuthenticationPolicy(self.credential, *self.credential_scopes, **kwargs)", - "credential_call_async": "AsyncARMChallengeAuthenticationPolicy(self.credential, *self.credential_scopes, **kwargs)", - "sync_imports": "{\"regular\": {\"sdkcore\": {\"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"ARMChallengeAuthenticationPolicy\", \"ARMHttpLoggingPolicy\"]}, \"local\": {\"._version\": [\"VERSION\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}}", - "async_imports": "{\"regular\": {\"sdkcore\": {\"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"ARMHttpLoggingPolicy\", \"AsyncARMChallengeAuthenticationPolicy\"]}, \"local\": {\".._version\": [\"VERSION\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"]}}}" - }, - "operation_groups": { - "keys": "KeysOperations", - "vaults": "VaultsOperations", - "private_endpoint_connections": "PrivateEndpointConnectionsOperations", - "private_link_resources": "PrivateLinkResourcesOperations", - "managed_hsms": "ManagedHsmsOperations", - "mhsm_private_endpoint_connections": "MHSMPrivateEndpointConnectionsOperations", - "mhsm_private_link_resources": "MHSMPrivateLinkResourcesOperations", - "operations": "Operations", - "secrets": "SecretsOperations" - } -} diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/_version.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/_version.py deleted file mode 100644 index 3b99a1418535..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/_version.py +++ /dev/null @@ -1,9 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -VERSION = "10.3.1" diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/__init__.py deleted file mode 100644 index 6ba0c5a05353..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/__init__.py +++ /dev/null @@ -1,23 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._key_vault_management_client import KeyVaultManagementClient - -try: - from ._patch import __all__ as _patch_all - from ._patch import * # pylint: disable=unused-wildcard-import -except ImportError: - _patch_all = [] -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "KeyVaultManagementClient", -] -__all__.extend([p for p in _patch_all if p not in __all__]) - -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/_configuration.py deleted file mode 100644 index 6f0e19d157e0..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/_configuration.py +++ /dev/null @@ -1,66 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from typing import Any, TYPE_CHECKING - -from azure.core.pipeline import policies -from azure.mgmt.core.policies import ARMHttpLoggingPolicy, AsyncARMChallengeAuthenticationPolicy - -from .._version import VERSION - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials_async import AsyncTokenCredential - - -class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long - """Configuration for KeyVaultManagementClient. - - Note that all parameters used to create this instance are saved as instance - attributes. - - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials_async.AsyncTokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :keyword api_version: Api Version. Default value is "2021-10-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str - """ - - def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None: - api_version: str = kwargs.pop("api_version", "2021-10-01") - - if credential is None: - raise ValueError("Parameter 'credential' must not be None.") - if subscription_id is None: - raise ValueError("Parameter 'subscription_id' must not be None.") - - self.credential = credential - self.subscription_id = subscription_id - self.api_version = api_version - self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) - kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) - self.polling_interval = kwargs.get("polling_interval", 30) - self._configure(**kwargs) - - def _configure(self, **kwargs: Any) -> None: - 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.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**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) - self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) - self.authentication_policy = kwargs.get("authentication_policy") - if self.credential and not self.authentication_policy: - self.authentication_policy = AsyncARMChallengeAuthenticationPolicy( - self.credential, *self.credential_scopes, **kwargs - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/_key_vault_management_client.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/_key_vault_management_client.py deleted file mode 100644 index 75eef2ec996d..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/_key_vault_management_client.py +++ /dev/null @@ -1,164 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from copy import deepcopy -from typing import Any, Awaitable, TYPE_CHECKING -from typing_extensions import Self - -from azure.core.pipeline import policies -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.mgmt.core import AsyncARMPipelineClient -from azure.mgmt.core.policies import AsyncARMAutoResourceProviderRegistrationPolicy - -from .. import models as _models -from ..._serialization import Deserializer, Serializer -from ._configuration import KeyVaultManagementClientConfiguration -from .operations import ( - KeysOperations, - MHSMPrivateEndpointConnectionsOperations, - MHSMPrivateLinkResourcesOperations, - ManagedHsmsOperations, - Operations, - PrivateEndpointConnectionsOperations, - PrivateLinkResourcesOperations, - SecretsOperations, - VaultsOperations, -) - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials_async import AsyncTokenCredential - - -class KeyVaultManagementClient: # pylint: disable=client-accepts-api-version-keyword,too-many-instance-attributes - """The Azure management API provides a RESTful set of web services that interact with Azure Key - Vault. - - :ivar keys: KeysOperations operations - :vartype keys: azure.mgmt.keyvault.v2021_10_01.aio.operations.KeysOperations - :ivar vaults: VaultsOperations operations - :vartype vaults: azure.mgmt.keyvault.v2021_10_01.aio.operations.VaultsOperations - :ivar private_endpoint_connections: PrivateEndpointConnectionsOperations operations - :vartype private_endpoint_connections: - azure.mgmt.keyvault.v2021_10_01.aio.operations.PrivateEndpointConnectionsOperations - :ivar private_link_resources: PrivateLinkResourcesOperations operations - :vartype private_link_resources: - azure.mgmt.keyvault.v2021_10_01.aio.operations.PrivateLinkResourcesOperations - :ivar managed_hsms: ManagedHsmsOperations operations - :vartype managed_hsms: azure.mgmt.keyvault.v2021_10_01.aio.operations.ManagedHsmsOperations - :ivar mhsm_private_endpoint_connections: MHSMPrivateEndpointConnectionsOperations operations - :vartype mhsm_private_endpoint_connections: - azure.mgmt.keyvault.v2021_10_01.aio.operations.MHSMPrivateEndpointConnectionsOperations - :ivar mhsm_private_link_resources: MHSMPrivateLinkResourcesOperations operations - :vartype mhsm_private_link_resources: - azure.mgmt.keyvault.v2021_10_01.aio.operations.MHSMPrivateLinkResourcesOperations - :ivar operations: Operations operations - :vartype operations: azure.mgmt.keyvault.v2021_10_01.aio.operations.Operations - :ivar secrets: SecretsOperations operations - :vartype secrets: azure.mgmt.keyvault.v2021_10_01.aio.operations.SecretsOperations - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials_async.AsyncTokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :param base_url: Service URL. Default value is "https://management.azure.com". - :type base_url: str - :keyword api_version: Api Version. Default value is "2021-10-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. - """ - - def __init__( - self, - credential: "AsyncTokenCredential", - subscription_id: str, - base_url: str = "https://management.azure.com", - **kwargs: Any - ) -> None: - self._config = KeyVaultManagementClientConfiguration( - credential=credential, subscription_id=subscription_id, **kwargs - ) - _policies = kwargs.pop("policies", None) - if _policies is None: - _policies = [ - policies.RequestIdPolicy(**kwargs), - self._config.headers_policy, - self._config.user_agent_policy, - self._config.proxy_policy, - policies.ContentDecodePolicy(**kwargs), - AsyncARMAutoResourceProviderRegistrationPolicy(), - self._config.redirect_policy, - self._config.retry_policy, - self._config.authentication_policy, - self._config.custom_hook_policy, - self._config.logging_policy, - policies.DistributedTracingPolicy(**kwargs), - policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, - self._config.http_logging_policy, - ] - self._client: AsyncARMPipelineClient = AsyncARMPipelineClient(base_url=base_url, policies=_policies, **kwargs) - - client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} - self._serialize = Serializer(client_models) - self._deserialize = Deserializer(client_models) - self._serialize.client_side_validation = False - self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize, "2021-10-01") - self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize, "2021-10-01") - self.private_endpoint_connections = PrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-10-01" - ) - self.private_link_resources = PrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-10-01" - ) - self.managed_hsms = ManagedHsmsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-10-01" - ) - self.mhsm_private_endpoint_connections = MHSMPrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-10-01" - ) - self.mhsm_private_link_resources = MHSMPrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2021-10-01" - ) - self.operations = Operations(self._client, self._config, self._serialize, self._deserialize, "2021-10-01") - self.secrets = SecretsOperations(self._client, self._config, self._serialize, self._deserialize, "2021-10-01") - - def _send_request( - self, request: HttpRequest, *, stream: bool = False, **kwargs: Any - ) -> Awaitable[AsyncHttpResponse]: - """Runs the network request through the client's chained policies. - - >>> from azure.core.rest import HttpRequest - >>> request = HttpRequest("GET", "https://www.example.org/") - - >>> response = await client._send_request(request) - - - For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request - - :param request: The network request you want to make. Required. - :type request: ~azure.core.rest.HttpRequest - :keyword bool stream: Whether the response payload will be streamed. Defaults to False. - :return: The response of your network call. Does not do error handling on your response. - :rtype: ~azure.core.rest.AsyncHttpResponse - """ - - request_copy = deepcopy(request) - request_copy.url = self._client.format_url(request_copy.url) - return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore - - async def close(self) -> None: - await self._client.close() - - async def __aenter__(self) -> Self: - await self._client.__aenter__() - return self - - async def __aexit__(self, *exc_details: Any) -> None: - await self._client.__aexit__(*exc_details) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/__init__.py deleted file mode 100644 index 224be3f73e55..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/__init__.py +++ /dev/null @@ -1,35 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._keys_operations import KeysOperations -from ._vaults_operations import VaultsOperations -from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations -from ._private_link_resources_operations import PrivateLinkResourcesOperations -from ._managed_hsms_operations import ManagedHsmsOperations -from ._mhsm_private_endpoint_connections_operations import MHSMPrivateEndpointConnectionsOperations -from ._mhsm_private_link_resources_operations import MHSMPrivateLinkResourcesOperations -from ._operations import Operations -from ._secrets_operations import SecretsOperations - -from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "KeysOperations", - "VaultsOperations", - "PrivateEndpointConnectionsOperations", - "PrivateLinkResourcesOperations", - "ManagedHsmsOperations", - "MHSMPrivateEndpointConnectionsOperations", - "MHSMPrivateLinkResourcesOperations", - "Operations", - "SecretsOperations", -] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_keys_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_keys_operations.py deleted file mode 100644 index bd07a8359a00..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_keys_operations.py +++ /dev/null @@ -1,507 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, Type, TypeVar, Union, overload -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._keys_operations import ( - build_create_if_not_exist_request, - build_get_request, - build_get_version_request, - build_list_request, - build_list_versions_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class KeysOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_10_01.aio.KeyVaultManagementClient`'s - :attr:`keys` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @overload - async def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: _models.KeyCreateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. The value you provide may be copied - globally for the purpose of running the service. The value provided should not include - personally identifiable or sensitive information. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.KeyCreateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. The value you provide may be copied - globally for the purpose of running the service. The value provided should not include - personally identifiable or sensitive information. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: Union[_models.KeyCreateParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. The value you provide may be copied - globally for the purpose of running the service. The value provided should not include - personally identifiable or sensitive information. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Is either a - KeyCreateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.KeyCreateParameters or IO[bytes] - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "KeyCreateParameters") - - _request = build_create_if_not_exist_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def get(self, resource_group_name: str, vault_name: str, key_name: str, **kwargs: Any) -> _models.Key: - """Gets the current version of the specified key from the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key to be retrieved. Required. - :type vault_name: str - :param key_name: The name of the key to be retrieved. Required. - :type key_name: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> AsyncIterable["_models.Key"]: - """Lists the keys in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the keys to be retrieved. Required. - :type vault_name: str - :return: An iterator like instance of either Key or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.Key] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("KeyListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace_async - async def get_version( - self, resource_group_name: str, vault_name: str, key_name: str, key_version: str, **kwargs: Any - ) -> _models.Key: - """Gets the specified version of the specified key in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key version to be retrieved. - Required. - :type vault_name: str - :param key_name: The name of the key version to be retrieved. Required. - :type key_name: str - :param key_version: The version of the key to be retrieved. Required. - :type key_version: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - _request = build_get_version_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - key_version=key_version, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_versions( - self, resource_group_name: str, vault_name: str, key_name: str, **kwargs: Any - ) -> AsyncIterable["_models.Key"]: - """Lists the versions of the specified key in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key versions to be retrieved. - Required. - :type vault_name: str - :param key_name: The name of the key versions to be retrieved. Required. - :type key_name: str - :return: An iterator like instance of either Key or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.Key] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_versions_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("KeyListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_managed_hsms_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_managed_hsms_operations.py deleted file mode 100644 index 7fbe368a1ed7..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_managed_hsms_operations.py +++ /dev/null @@ -1,1008 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._managed_hsms_operations import ( - build_create_or_update_request, - build_delete_request, - build_get_deleted_request, - build_get_request, - build_list_by_resource_group_request, - build_list_by_subscription_request, - build_list_deleted_request, - build_purge_deleted_request, - build_update_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class ManagedHsmsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_10_01.aio.KeyVaultManagementClient`'s - :attr:`managed_hsms` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - async def _create_or_update_initial( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "ManagedHsm") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def begin_create_or_update( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Is either a ManagedHsm - type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm or IO[bytes] - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._create_or_update_initial( - resource_group_name=resource_group_name, - name=name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.ManagedHsm].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.ManagedHsm]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - async def _update_initial( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "ManagedHsm") - - _request = build_update_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @overload - async def begin_update( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_update( - self, - resource_group_name: str, - name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def begin_update( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Is either a ManagedHsm type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm or IO[bytes] - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._update_initial( - resource_group_name=resource_group_name, - name=name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.ManagedHsm].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.ManagedHsm]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - async def _delete_initial(self, resource_group_name: str, name: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_delete(self, resource_group_name: str, name: str, **kwargs: Any) -> AsyncLROPoller[None]: - """Deletes the specified managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: The name of the managed HSM Pool to delete. Required. - :type name: str - :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._delete_initial( - resource_group_name=resource_group_name, - name=name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace_async - async def get(self, resource_group_name: str, name: str, **kwargs: Any) -> Optional[_models.ManagedHsm]: - """Gets the specified managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: The name of the managed HSM Pool. Required. - :type name: str - :return: ManagedHsm or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm or None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[Optional[_models.ManagedHsm]] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable["_models.ManagedHsm"]: - """The List operation gets information about the managed HSM Pools associated with the - subscription and within the specified resource group. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.ManagedHsm"]: - """The List operation gets information about the managed HSM Pools associated with the - subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedManagedHsm"]: - """The List operation gets information about the deleted managed HSMs associated with the - subscription. - - :return: An iterator like instance of either DeletedManagedHsm or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.DeletedManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.DeletedManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("DeletedManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace_async - async def get_deleted(self, name: str, location: str, **kwargs: Any) -> _models.DeletedManagedHsm: - """Gets the specified deleted managed HSM. - - :param name: The name of the deleted managed HSM. Required. - :type name: str - :param location: The location of the deleted managed HSM. Required. - :type location: str - :return: DeletedManagedHsm or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.DeletedManagedHsm - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.DeletedManagedHsm] = kwargs.pop("cls", None) - - _request = build_get_deleted_request( - name=name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = self._deserialize("DeletedManagedHsm", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - async def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_purge_deleted_request( - name=name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_purge_deleted(self, name: str, location: str, **kwargs: Any) -> AsyncLROPoller[None]: - """Permanently deletes the specified managed HSM. - - :param name: The name of the soft-deleted managed HSM. Required. - :type name: str - :param location: The location of the soft-deleted managed HSM. Required. - :type location: str - :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._purge_deleted_initial( - name=name, - location=location, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_mhsm_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_mhsm_private_endpoint_connections_operations.py deleted file mode 100644 index 088be29afcf1..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_mhsm_private_endpoint_connections_operations.py +++ /dev/null @@ -1,488 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._mhsm_private_endpoint_connections_operations import ( - build_delete_request, - build_get_request, - build_list_by_resource_request, - build_put_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class MHSMPrivateEndpointConnectionsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_10_01.aio.KeyVaultManagementClient`'s - :attr:`mhsm_private_endpoint_connections` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list_by_resource( - self, resource_group_name: str, name: str, **kwargs: Any - ) -> AsyncIterable["_models.MHSMPrivateEndpointConnection"]: - """The List operation gets information about the private endpoint connections associated with the - managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :return: An iterator like instance of either MHSMPrivateEndpointConnection or the result of - cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("MHSMPrivateEndpointConnectionsListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace_async - async def get( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Gets the specified private endpoint connection associated with the managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: _models.MHSMPrivateEndpointConnection, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: Union[_models.MHSMPrivateEndpointConnection, IO[bytes]], - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Is either a - MHSMPrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection or - IO[bytes] - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _json = self._serialize.body(properties, "MHSMPrivateEndpointConnection") - - _request = build_put_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Azure-AsyncOperation"] = self._deserialize( - "str", response.headers.get("Azure-AsyncOperation") - ) - - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - async def _delete_initial( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_delete( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> AsyncLROPoller[_models.MHSMPrivateEndpointConnection]: - """Deletes the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :return: An instance of AsyncLROPoller that returns either MHSMPrivateEndpointConnection or the - result of cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._delete_initial( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.MHSMPrivateEndpointConnection].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.MHSMPrivateEndpointConnection]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_operations.py deleted file mode 100644 index 69930eec13c7..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_operations.py +++ /dev/null @@ -1,131 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, AsyncIterable, Callable, Dict, Optional, Type, TypeVar -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._operations import build_list_request - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class Operations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_10_01.aio.KeyVaultManagementClient`'s - :attr:`operations` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: - """Lists all of the available Key Vault Rest API operations. - - :return: An iterator like instance of either Operation or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.Operation] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("OperationListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_patch.py deleted file mode 100644 index 9b4f32f151b7..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_patch.py +++ /dev/null @@ -1,136 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -import sys -from typing import AsyncIterable, Any, Optional, List, Type -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ._vaults_operations import VaultsOperations as _VaultsOperations, ClsType -from ...operations._vaults_operations import build_list_request - -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports - -class VaultsOperations(_VaultsOperations): - - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - -__all__: List[str] = ["VaultsOperations"] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_private_endpoint_connections_operations.py deleted file mode 100644 index d467a5d4dbdb..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_private_endpoint_connections_operations.py +++ /dev/null @@ -1,482 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._private_endpoint_connections_operations import ( - build_delete_request, - build_get_request, - build_list_by_resource_request, - build_put_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class PrivateEndpointConnectionsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_10_01.aio.KeyVaultManagementClient`'s - :attr:`private_endpoint_connections` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace_async - async def get( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Optional[_models.PrivateEndpointConnection]: - """Gets the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: PrivateEndpointConnection or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection or None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[Optional[_models.PrivateEndpointConnection]] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: _models.PrivateEndpointConnection, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: Union[_models.PrivateEndpointConnection, IO[bytes]], - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Is either a - PrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection or - IO[bytes] - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _json = self._serialize.body(properties, "PrivateEndpointConnection") - - _request = build_put_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Azure-AsyncOperation"] = self._deserialize( - "str", response.headers.get("Azure-AsyncOperation") - ) - - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - async def _delete_initial( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_delete( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> AsyncLROPoller[_models.PrivateEndpointConnection]: - """Deletes the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: An instance of AsyncLROPoller that returns either PrivateEndpointConnection or the - result of cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._delete_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.PrivateEndpointConnection].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.PrivateEndpointConnection]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @distributed_trace - def list_by_resource( - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> AsyncIterable["_models.PrivateEndpointConnection"]: - """The List operation gets information about the private endpoint connections associated with the - vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :return: An iterator like instance of either PrivateEndpointConnection or the result of - cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.PrivateEndpointConnectionListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("PrivateEndpointConnectionListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_private_link_resources_operations.py deleted file mode 100644 index fcdf64fdc1aa..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_private_link_resources_operations.py +++ /dev/null @@ -1,111 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._private_link_resources_operations import build_list_by_vault_request - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class PrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_10_01.aio.KeyVaultManagementClient`'s - :attr:`private_link_resources` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace_async - async def list_by_vault( - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> _models.PrivateLinkResourceListResult: - """Gets the private link resources supported for the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :return: PrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateLinkResourceListResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.PrivateLinkResourceListResult] = kwargs.pop("cls", None) - - _request = build_list_by_vault_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_secrets_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_secrets_operations.py deleted file mode 100644 index dca59c833418..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_secrets_operations.py +++ /dev/null @@ -1,518 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, Type, TypeVar, Union, overload -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._secrets_operations import ( - build_create_or_update_request, - build_get_request, - build_list_request, - build_update_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class SecretsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_10_01.aio.KeyVaultManagementClient`'s - :attr:`secrets` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @overload - async def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: _models.SecretCreateOrUpdateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. The value you provide may be copied globally for the - purpose of running the service. The value provided should not include personally identifiable - or sensitive information. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.SecretCreateOrUpdateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. The value you provide may be copied globally for the - purpose of running the service. The value provided should not include personally identifiable - or sensitive information. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: Union[_models.SecretCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. The value you provide may be copied globally for the - purpose of running the service. The value provided should not include personally identifiable - or sensitive information. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Is either a - SecretCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.SecretCreateOrUpdateParameters or - IO[bytes] - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "SecretCreateOrUpdateParameters") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: _models.SecretPatchParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.SecretPatchParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: Union[_models.SecretPatchParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Is either a SecretPatchParameters type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.SecretPatchParameters or IO[bytes] - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "SecretPatchParameters") - - _request = build_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def get(self, resource_group_name: str, vault_name: str, secret_name: str, **kwargs: Any) -> _models.Secret: - """Gets the specified secret. NOTE: This API is intended for internal use in ARM deployments. - Users should use the data-plane REST service for interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param secret_name: The name of the secret. Required. - :type secret_name: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list( - self, resource_group_name: str, vault_name: str, top: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable["_models.Secret"]: - """The List operation gets information about the secrets in a vault. NOTE: This API is intended - for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Secret or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.Secret] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.SecretListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("SecretListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_vaults_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_vaults_operations.py deleted file mode 100644 index 5ea6b06ed3f2..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_vaults_operations.py +++ /dev/null @@ -1,1244 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import ( - Any, - AsyncIterable, - AsyncIterator, - Callable, - Dict, - IO, - Literal, - Optional, - Type, - TypeVar, - Union, - cast, - overload, -) -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._vaults_operations import ( - build_check_name_availability_request, - build_create_or_update_request, - build_delete_request, - build_get_deleted_request, - build_get_request, - build_list_by_resource_group_request, - build_list_by_subscription_request, - build_list_deleted_request, - build_list_request, - build_purge_deleted_request, - build_update_access_policy_request, - build_update_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class VaultsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_10_01.aio.KeyVaultManagementClient`'s - :attr:`vaults` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - async def _create_or_update_initial( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 201: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.VaultCreateOrUpdateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_10_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_10_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> AsyncLROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Is either a - VaultCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.VaultCreateOrUpdateParameters or - IO[bytes] - :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_10_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._create_or_update_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("Vault", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.Vault].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.Vault]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @overload - async def update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultPatchParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.VaultPatchParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultPatchParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Is either a VaultPatchParameters type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.VaultPatchParameters or IO[bytes] - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultPatchParameters") - - _request = build_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def delete( # pylint: disable=inconsistent-return-statements - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> None: - """Deletes the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault to delete. Required. - :type vault_name: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - @distributed_trace_async - async def get(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> _models.Vault: - """Gets the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: _models.VaultAccessPolicyParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2021_10_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.VaultAccessPolicyParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2021_10_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: Union[_models.VaultAccessPolicyParameters, IO[bytes]], - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2021_10_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Is either a - VaultAccessPolicyParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.VaultAccessPolicyParameters or - IO[bytes] - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.VaultAccessPolicyParameters] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") - - _request = build_update_access_policy_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - operation_kind=operation_kind, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription and - within the specified resource group. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedVault"]: - """Gets information about the deleted vaults in a subscription. - - :return: An iterator like instance of either DeletedVault or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.DeletedVault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.DeletedVaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("DeletedVaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace_async - async def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _models.DeletedVault: - """Gets the deleted Azure key vault. - - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param location: The location of the deleted vault. Required. - :type location: str - :return: DeletedVault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.DeletedVault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.DeletedVault] = kwargs.pop("cls", None) - - _request = build_get_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("DeletedVault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - async def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_purge_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_purge_deleted(self, vault_name: str, location: str, **kwargs: Any) -> AsyncLROPoller[None]: - """Permanently deletes the specified vault. aka Purges the deleted Azure key vault. - - :param vault_name: The name of the soft-deleted vault. Required. - :type vault_name: str - :param location: The location of the soft-deleted vault. Required. - :type location: str - :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._purge_deleted_initial( - vault_name=vault_name, - location=location, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @overload - async def check_name_availability( - self, - vault_name: _models.VaultCheckNameAvailabilityParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: ~azure.mgmt.keyvault.v2021_10_01.models.VaultCheckNameAvailabilityParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def check_name_availability( - self, vault_name: IO[bytes], *, content_type: str = "application/json", **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def check_name_availability( - self, vault_name: Union[_models.VaultCheckNameAvailabilityParameters, IO[bytes]], **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Is either a VaultCheckNameAvailabilityParameters type - or a IO[bytes] type. Required. - :type vault_name: ~azure.mgmt.keyvault.v2021_10_01.models.VaultCheckNameAvailabilityParameters - or IO[bytes] - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.CheckNameAvailabilityResult] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(vault_name, (IOBase, bytes)): - _content = vault_name - else: - _json = self._serialize.body(vault_name, "VaultCheckNameAvailabilityParameters") - - _request = build_check_name_availability_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/models/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/models/__init__.py deleted file mode 100644 index 335f8a2a6621..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/models/__init__.py +++ /dev/null @@ -1,205 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._models_py3 import AccessPolicyEntry -from ._models_py3 import Attributes -from ._models_py3 import CheckNameAvailabilityResult -from ._models_py3 import CloudErrorBody -from ._models_py3 import DeletedManagedHsm -from ._models_py3 import DeletedManagedHsmListResult -from ._models_py3 import DeletedManagedHsmProperties -from ._models_py3 import DeletedVault -from ._models_py3 import DeletedVaultListResult -from ._models_py3 import DeletedVaultProperties -from ._models_py3 import DimensionProperties -from ._models_py3 import Error -from ._models_py3 import IPRule -from ._models_py3 import Key -from ._models_py3 import KeyAttributes -from ._models_py3 import KeyCreateParameters -from ._models_py3 import KeyListResult -from ._models_py3 import KeyProperties -from ._models_py3 import LogSpecification -from ._models_py3 import MHSMIPRule -from ._models_py3 import MHSMNetworkRuleSet -from ._models_py3 import MHSMPrivateEndpoint -from ._models_py3 import MHSMPrivateEndpointConnection -from ._models_py3 import MHSMPrivateEndpointConnectionItem -from ._models_py3 import MHSMPrivateEndpointConnectionsListResult -from ._models_py3 import MHSMPrivateLinkResource -from ._models_py3 import MHSMPrivateLinkResourceListResult -from ._models_py3 import MHSMPrivateLinkServiceConnectionState -from ._models_py3 import MHSMVirtualNetworkRule -from ._models_py3 import ManagedHsm -from ._models_py3 import ManagedHsmError -from ._models_py3 import ManagedHsmListResult -from ._models_py3 import ManagedHsmProperties -from ._models_py3 import ManagedHsmResource -from ._models_py3 import ManagedHsmSku -from ._models_py3 import MetricSpecification -from ._models_py3 import NetworkRuleSet -from ._models_py3 import Operation -from ._models_py3 import OperationDisplay -from ._models_py3 import OperationListResult -from ._models_py3 import Permissions -from ._models_py3 import PrivateEndpoint -from ._models_py3 import PrivateEndpointConnection -from ._models_py3 import PrivateEndpointConnectionItem -from ._models_py3 import PrivateEndpointConnectionListResult -from ._models_py3 import PrivateLinkResource -from ._models_py3 import PrivateLinkResourceListResult -from ._models_py3 import PrivateLinkServiceConnectionState -from ._models_py3 import Resource -from ._models_py3 import ResourceListResult -from ._models_py3 import Secret -from ._models_py3 import SecretAttributes -from ._models_py3 import SecretCreateOrUpdateParameters -from ._models_py3 import SecretListResult -from ._models_py3 import SecretPatchParameters -from ._models_py3 import SecretPatchProperties -from ._models_py3 import SecretProperties -from ._models_py3 import ServiceSpecification -from ._models_py3 import Sku -from ._models_py3 import SystemData -from ._models_py3 import Vault -from ._models_py3 import VaultAccessPolicyParameters -from ._models_py3 import VaultAccessPolicyProperties -from ._models_py3 import VaultCheckNameAvailabilityParameters -from ._models_py3 import VaultCreateOrUpdateParameters -from ._models_py3 import VaultListResult -from ._models_py3 import VaultPatchParameters -from ._models_py3 import VaultPatchProperties -from ._models_py3 import VaultProperties -from ._models_py3 import VirtualNetworkRule - -from ._key_vault_management_client_enums import AccessPolicyUpdateKind -from ._key_vault_management_client_enums import ActionsRequired -from ._key_vault_management_client_enums import CertificatePermissions -from ._key_vault_management_client_enums import CreateMode -from ._key_vault_management_client_enums import DeletionRecoveryLevel -from ._key_vault_management_client_enums import IdentityType -from ._key_vault_management_client_enums import JsonWebKeyCurveName -from ._key_vault_management_client_enums import JsonWebKeyOperation -from ._key_vault_management_client_enums import JsonWebKeyType -from ._key_vault_management_client_enums import KeyPermissions -from ._key_vault_management_client_enums import ManagedHsmSkuFamily -from ._key_vault_management_client_enums import ManagedHsmSkuName -from ._key_vault_management_client_enums import NetworkRuleAction -from ._key_vault_management_client_enums import NetworkRuleBypassOptions -from ._key_vault_management_client_enums import PrivateEndpointConnectionProvisioningState -from ._key_vault_management_client_enums import PrivateEndpointServiceConnectionStatus -from ._key_vault_management_client_enums import ProvisioningState -from ._key_vault_management_client_enums import PublicNetworkAccess -from ._key_vault_management_client_enums import Reason -from ._key_vault_management_client_enums import SecretPermissions -from ._key_vault_management_client_enums import SkuFamily -from ._key_vault_management_client_enums import SkuName -from ._key_vault_management_client_enums import StoragePermissions -from ._key_vault_management_client_enums import VaultProvisioningState -from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "AccessPolicyEntry", - "Attributes", - "CheckNameAvailabilityResult", - "CloudErrorBody", - "DeletedManagedHsm", - "DeletedManagedHsmListResult", - "DeletedManagedHsmProperties", - "DeletedVault", - "DeletedVaultListResult", - "DeletedVaultProperties", - "DimensionProperties", - "Error", - "IPRule", - "Key", - "KeyAttributes", - "KeyCreateParameters", - "KeyListResult", - "KeyProperties", - "LogSpecification", - "MHSMIPRule", - "MHSMNetworkRuleSet", - "MHSMPrivateEndpoint", - "MHSMPrivateEndpointConnection", - "MHSMPrivateEndpointConnectionItem", - "MHSMPrivateEndpointConnectionsListResult", - "MHSMPrivateLinkResource", - "MHSMPrivateLinkResourceListResult", - "MHSMPrivateLinkServiceConnectionState", - "MHSMVirtualNetworkRule", - "ManagedHsm", - "ManagedHsmError", - "ManagedHsmListResult", - "ManagedHsmProperties", - "ManagedHsmResource", - "ManagedHsmSku", - "MetricSpecification", - "NetworkRuleSet", - "Operation", - "OperationDisplay", - "OperationListResult", - "Permissions", - "PrivateEndpoint", - "PrivateEndpointConnection", - "PrivateEndpointConnectionItem", - "PrivateEndpointConnectionListResult", - "PrivateLinkResource", - "PrivateLinkResourceListResult", - "PrivateLinkServiceConnectionState", - "Resource", - "ResourceListResult", - "Secret", - "SecretAttributes", - "SecretCreateOrUpdateParameters", - "SecretListResult", - "SecretPatchParameters", - "SecretPatchProperties", - "SecretProperties", - "ServiceSpecification", - "Sku", - "SystemData", - "Vault", - "VaultAccessPolicyParameters", - "VaultAccessPolicyProperties", - "VaultCheckNameAvailabilityParameters", - "VaultCreateOrUpdateParameters", - "VaultListResult", - "VaultPatchParameters", - "VaultPatchProperties", - "VaultProperties", - "VirtualNetworkRule", - "AccessPolicyUpdateKind", - "ActionsRequired", - "CertificatePermissions", - "CreateMode", - "DeletionRecoveryLevel", - "IdentityType", - "JsonWebKeyCurveName", - "JsonWebKeyOperation", - "JsonWebKeyType", - "KeyPermissions", - "ManagedHsmSkuFamily", - "ManagedHsmSkuName", - "NetworkRuleAction", - "NetworkRuleBypassOptions", - "PrivateEndpointConnectionProvisioningState", - "PrivateEndpointServiceConnectionStatus", - "ProvisioningState", - "PublicNetworkAccess", - "Reason", - "SecretPermissions", - "SkuFamily", - "SkuName", - "StoragePermissions", - "VaultProvisioningState", -] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/models/_key_vault_management_client_enums.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/models/_key_vault_management_client_enums.py deleted file mode 100644 index 66c50daa77e6..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/models/_key_vault_management_client_enums.py +++ /dev/null @@ -1,274 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from enum import Enum -from azure.core import CaseInsensitiveEnumMeta - - -class AccessPolicyUpdateKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """AccessPolicyUpdateKind.""" - - ADD = "add" - REPLACE = "replace" - REMOVE = "remove" - - -class ActionsRequired(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """A message indicating if changes on the service provider require any updates on the consumer.""" - - NONE = "None" - - -class CertificatePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """CertificatePermissions.""" - - ALL = "all" - GET = "get" - LIST = "list" - DELETE = "delete" - CREATE = "create" - IMPORT = "import" - UPDATE = "update" - MANAGECONTACTS = "managecontacts" - GETISSUERS = "getissuers" - LISTISSUERS = "listissuers" - SETISSUERS = "setissuers" - DELETEISSUERS = "deleteissuers" - MANAGEISSUERS = "manageissuers" - RECOVER = "recover" - PURGE = "purge" - BACKUP = "backup" - RESTORE = "restore" - IMPORT_ENUM = "import" - - -class CreateMode(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The vault's create mode to indicate whether the vault need to be recovered or not.""" - - RECOVER = "recover" - DEFAULT = "default" - - -class DeletionRecoveryLevel(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The deletion recovery level currently in effect for the object. If it contains 'Purgeable', - then the object can be permanently deleted by a privileged user; otherwise, only the system can - purge the object at the end of the retention interval. - """ - - PURGEABLE = "Purgeable" - RECOVERABLE_PURGEABLE = "Recoverable+Purgeable" - RECOVERABLE = "Recoverable" - RECOVERABLE_PROTECTED_SUBSCRIPTION = "Recoverable+ProtectedSubscription" - - -class IdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of identity.""" - - USER = "User" - APPLICATION = "Application" - MANAGED_IDENTITY = "ManagedIdentity" - KEY = "Key" - - -class JsonWebKeyCurveName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The elliptic curve name. For valid values, see JsonWebKeyCurveName.""" - - P256 = "P-256" - P384 = "P-384" - P521 = "P-521" - P256_K = "P-256K" - - -class JsonWebKeyOperation(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The permitted JSON web key operations of the key. For more information, see - JsonWebKeyOperation. - """ - - ENCRYPT = "encrypt" - DECRYPT = "decrypt" - SIGN = "sign" - VERIFY = "verify" - WRAP_KEY = "wrapKey" - UNWRAP_KEY = "unwrapKey" - IMPORT = "import" - IMPORT_ENUM = "import" - - -class JsonWebKeyType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of the key. For valid values, see JsonWebKeyType.""" - - EC = "EC" - EC_HSM = "EC-HSM" - RSA = "RSA" - RSA_HSM = "RSA-HSM" - - -class KeyPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """KeyPermissions.""" - - ALL = "all" - ENCRYPT = "encrypt" - DECRYPT = "decrypt" - WRAP_KEY = "wrapKey" - UNWRAP_KEY = "unwrapKey" - SIGN = "sign" - VERIFY = "verify" - GET = "get" - LIST = "list" - CREATE = "create" - UPDATE = "update" - IMPORT = "import" - DELETE = "delete" - BACKUP = "backup" - RESTORE = "restore" - RECOVER = "recover" - PURGE = "purge" - IMPORT_ENUM = "import" - - -class ManagedHsmSkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU Family of the managed HSM Pool.""" - - B = "B" - - -class ManagedHsmSkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU of the managed HSM Pool.""" - - STANDARD_B1 = "Standard_B1" - CUSTOM_B32 = "Custom_B32" - CUSTOM_B6 = "Custom_B6" - - -class NetworkRuleAction(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The default action when no rule from ipRules and from virtualNetworkRules match. This is only - used after the bypass property has been evaluated. - """ - - ALLOW = "Allow" - DENY = "Deny" - - -class NetworkRuleBypassOptions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Tells what traffic can bypass network rules. This can be 'AzureServices' or 'None'. If not - specified the default is 'AzureServices'. - """ - - AZURE_SERVICES = "AzureServices" - NONE = "None" - - -class PrivateEndpointConnectionProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The current provisioning state.""" - - SUCCEEDED = "Succeeded" - CREATING = "Creating" - UPDATING = "Updating" - DELETING = "Deleting" - FAILED = "Failed" - DISCONNECTED = "Disconnected" - - -class PrivateEndpointServiceConnectionStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The private endpoint connection status.""" - - PENDING = "Pending" - APPROVED = "Approved" - REJECTED = "Rejected" - DISCONNECTED = "Disconnected" - - -class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Provisioning state.""" - - SUCCEEDED = "Succeeded" - """The managed HSM Pool has been full provisioned.""" - PROVISIONING = "Provisioning" - """The managed HSM Pool is currently being provisioned.""" - FAILED = "Failed" - """Provisioning of the managed HSM Pool has failed.""" - UPDATING = "Updating" - """The managed HSM Pool is currently being updated.""" - DELETING = "Deleting" - """The managed HSM Pool is currently being deleted.""" - ACTIVATED = "Activated" - """The managed HSM pool is ready for normal use.""" - SECURITY_DOMAIN_RESTORE = "SecurityDomainRestore" - """The managed HSM pool is waiting for a security domain restore action.""" - RESTORING = "Restoring" - """The managed HSM pool is being restored from full HSM backup.""" - - -class PublicNetworkAccess(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Control permission to the managed HSM from public networks.""" - - ENABLED = "Enabled" - DISABLED = "Disabled" - - -class Reason(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The reason that a vault name could not be used. The Reason element is only returned if - NameAvailable is false. - """ - - ACCOUNT_NAME_INVALID = "AccountNameInvalid" - ALREADY_EXISTS = "AlreadyExists" - - -class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SecretPermissions.""" - - ALL = "all" - GET = "get" - LIST = "list" - SET = "set" - DELETE = "delete" - BACKUP = "backup" - RESTORE = "restore" - RECOVER = "recover" - PURGE = "purge" - - -class SkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU family name.""" - - A = "A" - - -class SkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU name to specify whether the key vault is a standard vault or a premium vault.""" - - STANDARD = "standard" - PREMIUM = "premium" - - -class StoragePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """StoragePermissions.""" - - ALL = "all" - GET = "get" - LIST = "list" - DELETE = "delete" - SET = "set" - UPDATE = "update" - REGENERATEKEY = "regeneratekey" - RECOVER = "recover" - PURGE = "purge" - BACKUP = "backup" - RESTORE = "restore" - SETSAS = "setsas" - LISTSAS = "listsas" - GETSAS = "getsas" - DELETESAS = "deletesas" - - -class VaultProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Provisioning state of the vault.""" - - SUCCEEDED = "Succeeded" - REGISTERING_DNS = "RegisteringDns" diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/models/_models_py3.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/models/_models_py3.py deleted file mode 100644 index 9fdaac3f821b..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/models/_models_py3.py +++ /dev/null @@ -1,3481 +0,0 @@ -# coding=utf-8 -# pylint: disable=too-many-lines -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -import datetime -from typing import Any, Dict, List, Optional, TYPE_CHECKING, Union - -from ... import _serialization - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from .. import models as _models - - -class AccessPolicyEntry(_serialization.Model): - """An identity that have access to the key vault. All identities in the array must use the same - tenant ID as the key vault's tenant ID. - - All required parameters must be populated in order to send to server. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :vartype tenant_id: str - :ivar object_id: The object ID of a user, service principal or security group in the Azure - Active Directory tenant for the vault. The object ID must be unique for the list of access - policies. Required. - :vartype object_id: str - :ivar application_id: Application ID of the client making request on behalf of a principal. - :vartype application_id: str - :ivar permissions: Permissions the identity has for keys, secrets and certificates. Required. - :vartype permissions: ~azure.mgmt.keyvault.v2021_10_01.models.Permissions - """ - - _validation = { - "tenant_id": {"required": True}, - "object_id": {"required": True}, - "permissions": {"required": True}, - } - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "object_id": {"key": "objectId", "type": "str"}, - "application_id": {"key": "applicationId", "type": "str"}, - "permissions": {"key": "permissions", "type": "Permissions"}, - } - - def __init__( - self, - *, - tenant_id: str, - object_id: str, - permissions: "_models.Permissions", - application_id: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :paramtype tenant_id: str - :keyword object_id: The object ID of a user, service principal or security group in the Azure - Active Directory tenant for the vault. The object ID must be unique for the list of access - policies. Required. - :paramtype object_id: str - :keyword application_id: Application ID of the client making request on behalf of a principal. - :paramtype application_id: str - :keyword permissions: Permissions the identity has for keys, secrets and certificates. - Required. - :paramtype permissions: ~azure.mgmt.keyvault.v2021_10_01.models.Permissions - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.object_id = object_id - self.application_id = application_id - self.permissions = permissions - - -class Attributes(_serialization.Model): - """The object attributes managed by the KeyVault service. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar enabled: Determines whether the object is enabled. - :vartype enabled: bool - :ivar not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :vartype not_before: ~datetime.datetime - :ivar expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :vartype expires: ~datetime.datetime - :ivar created: Creation time in seconds since 1970-01-01T00:00:00Z. - :vartype created: ~datetime.datetime - :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: ~datetime.datetime - """ - - _validation = { - "created": {"readonly": True}, - "updated": {"readonly": True}, - } - - _attribute_map = { - "enabled": {"key": "enabled", "type": "bool"}, - "not_before": {"key": "nbf", "type": "unix-time"}, - "expires": {"key": "exp", "type": "unix-time"}, - "created": {"key": "created", "type": "unix-time"}, - "updated": {"key": "updated", "type": "unix-time"}, - } - - def __init__( - self, - *, - enabled: Optional[bool] = None, - not_before: Optional[datetime.datetime] = None, - expires: Optional[datetime.datetime] = None, - **kwargs: Any - ) -> None: - """ - :keyword enabled: Determines whether the object is enabled. - :paramtype enabled: bool - :keyword not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :paramtype not_before: ~datetime.datetime - :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :paramtype expires: ~datetime.datetime - """ - super().__init__(**kwargs) - self.enabled = enabled - self.not_before = not_before - self.expires = expires - self.created = None - self.updated = None - - -class CheckNameAvailabilityResult(_serialization.Model): - """The CheckNameAvailability operation response. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar name_available: A boolean value that indicates whether the name is available for you to - use. If true, the name is available. If false, the name has already been taken or is invalid - and cannot be used. - :vartype name_available: bool - :ivar reason: The reason that a vault name could not be used. The Reason element is only - returned if NameAvailable is false. Known values are: "AccountNameInvalid" and "AlreadyExists". - :vartype reason: str or ~azure.mgmt.keyvault.v2021_10_01.models.Reason - :ivar message: An error message explaining the Reason value in more detail. - :vartype message: str - """ - - _validation = { - "name_available": {"readonly": True}, - "reason": {"readonly": True}, - "message": {"readonly": True}, - } - - _attribute_map = { - "name_available": {"key": "nameAvailable", "type": "bool"}, - "reason": {"key": "reason", "type": "str"}, - "message": {"key": "message", "type": "str"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.name_available = None - self.reason = None - self.message = None - - -class CloudErrorBody(_serialization.Model): - """An error response from Key Vault resource provider. - - :ivar code: Error code. This is a mnemonic that can be consumed programmatically. - :vartype code: str - :ivar message: User friendly error message. The message is typically localized and may vary - with service version. - :vartype message: str - """ - - _attribute_map = { - "code": {"key": "code", "type": "str"}, - "message": {"key": "message", "type": "str"}, - } - - def __init__(self, *, code: Optional[str] = None, message: Optional[str] = None, **kwargs: Any) -> None: - """ - :keyword code: Error code. This is a mnemonic that can be consumed programmatically. - :paramtype code: str - :keyword message: User friendly error message. The message is typically localized and may vary - with service version. - :paramtype message: str - """ - super().__init__(**kwargs) - self.code = code - self.message = message - - -class DeletedManagedHsm(_serialization.Model): - """DeletedManagedHsm. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The Azure Resource Manager resource ID for the deleted managed HSM Pool. - :vartype id: str - :ivar name: The name of the managed HSM Pool. - :vartype name: str - :ivar type: The resource type of the managed HSM Pool. - :vartype type: str - :ivar properties: Properties of the deleted managed HSM. - :vartype properties: ~azure.mgmt.keyvault.v2021_10_01.models.DeletedManagedHsmProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "properties": {"key": "properties", "type": "DeletedManagedHsmProperties"}, - } - - def __init__(self, *, properties: Optional["_models.DeletedManagedHsmProperties"] = None, **kwargs: Any) -> None: - """ - :keyword properties: Properties of the deleted managed HSM. - :paramtype properties: ~azure.mgmt.keyvault.v2021_10_01.models.DeletedManagedHsmProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.properties = properties - - -class DeletedManagedHsmListResult(_serialization.Model): - """List of deleted managed HSM Pools. - - :ivar value: The list of deleted managed HSM Pools. - :vartype value: list[~azure.mgmt.keyvault.v2021_10_01.models.DeletedManagedHsm] - :ivar next_link: The URL to get the next set of deleted managed HSM Pools. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[DeletedManagedHsm]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, - *, - value: Optional[List["_models.DeletedManagedHsm"]] = None, - next_link: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword value: The list of deleted managed HSM Pools. - :paramtype value: list[~azure.mgmt.keyvault.v2021_10_01.models.DeletedManagedHsm] - :keyword next_link: The URL to get the next set of deleted managed HSM Pools. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class DeletedManagedHsmProperties(_serialization.Model): - """Properties of the deleted managed HSM. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar mhsm_id: The resource id of the original managed HSM. - :vartype mhsm_id: str - :ivar location: The location of the original managed HSM. - :vartype location: str - :ivar deletion_date: The deleted date. - :vartype deletion_date: ~datetime.datetime - :ivar scheduled_purge_date: The scheduled purged date. - :vartype scheduled_purge_date: ~datetime.datetime - :ivar purge_protection_enabled: Purge protection status of the original managed HSM. - :vartype purge_protection_enabled: bool - :ivar tags: Tags of the original managed HSM. - :vartype tags: dict[str, str] - """ - - _validation = { - "mhsm_id": {"readonly": True}, - "location": {"readonly": True}, - "deletion_date": {"readonly": True}, - "scheduled_purge_date": {"readonly": True}, - "purge_protection_enabled": {"readonly": True}, - "tags": {"readonly": True}, - } - - _attribute_map = { - "mhsm_id": {"key": "mhsmId", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "deletion_date": {"key": "deletionDate", "type": "iso-8601"}, - "scheduled_purge_date": {"key": "scheduledPurgeDate", "type": "iso-8601"}, - "purge_protection_enabled": {"key": "purgeProtectionEnabled", "type": "bool"}, - "tags": {"key": "tags", "type": "{str}"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.mhsm_id = None - self.location = None - self.deletion_date = None - self.scheduled_purge_date = None - self.purge_protection_enabled = None - self.tags = None - - -class DeletedVault(_serialization.Model): - """Deleted vault information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The resource ID for the deleted key vault. - :vartype id: str - :ivar name: The name of the key vault. - :vartype name: str - :ivar type: The resource type of the key vault. - :vartype type: str - :ivar properties: Properties of the vault. - :vartype properties: ~azure.mgmt.keyvault.v2021_10_01.models.DeletedVaultProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "properties": {"key": "properties", "type": "DeletedVaultProperties"}, - } - - def __init__(self, *, properties: Optional["_models.DeletedVaultProperties"] = None, **kwargs: Any) -> None: - """ - :keyword properties: Properties of the vault. - :paramtype properties: ~azure.mgmt.keyvault.v2021_10_01.models.DeletedVaultProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.properties = properties - - -class DeletedVaultListResult(_serialization.Model): - """List of vaults. - - :ivar value: The list of deleted vaults. - :vartype value: list[~azure.mgmt.keyvault.v2021_10_01.models.DeletedVault] - :ivar next_link: The URL to get the next set of deleted vaults. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[DeletedVault]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.DeletedVault"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of deleted vaults. - :paramtype value: list[~azure.mgmt.keyvault.v2021_10_01.models.DeletedVault] - :keyword next_link: The URL to get the next set of deleted vaults. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class DeletedVaultProperties(_serialization.Model): - """Properties of the deleted vault. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar vault_id: The resource id of the original vault. - :vartype vault_id: str - :ivar location: The location of the original vault. - :vartype location: str - :ivar deletion_date: The deleted date. - :vartype deletion_date: ~datetime.datetime - :ivar scheduled_purge_date: The scheduled purged date. - :vartype scheduled_purge_date: ~datetime.datetime - :ivar tags: Tags of the original vault. - :vartype tags: dict[str, str] - :ivar purge_protection_enabled: Purge protection status of the original vault. - :vartype purge_protection_enabled: bool - """ - - _validation = { - "vault_id": {"readonly": True}, - "location": {"readonly": True}, - "deletion_date": {"readonly": True}, - "scheduled_purge_date": {"readonly": True}, - "tags": {"readonly": True}, - "purge_protection_enabled": {"readonly": True}, - } - - _attribute_map = { - "vault_id": {"key": "vaultId", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "deletion_date": {"key": "deletionDate", "type": "iso-8601"}, - "scheduled_purge_date": {"key": "scheduledPurgeDate", "type": "iso-8601"}, - "tags": {"key": "tags", "type": "{str}"}, - "purge_protection_enabled": {"key": "purgeProtectionEnabled", "type": "bool"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.vault_id = None - self.location = None - self.deletion_date = None - self.scheduled_purge_date = None - self.tags = None - self.purge_protection_enabled = None - - -class DimensionProperties(_serialization.Model): - """Type of operation: get, read, delete, etc. - - :ivar name: Name of dimension. - :vartype name: str - :ivar display_name: Display name of dimension. - :vartype display_name: str - :ivar to_be_exported_for_shoebox: Property to specify whether the dimension should be exported - for Shoebox. - :vartype to_be_exported_for_shoebox: bool - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display_name": {"key": "displayName", "type": "str"}, - "to_be_exported_for_shoebox": {"key": "toBeExportedForShoebox", "type": "bool"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display_name: Optional[str] = None, - to_be_exported_for_shoebox: Optional[bool] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Name of dimension. - :paramtype name: str - :keyword display_name: Display name of dimension. - :paramtype display_name: str - :keyword to_be_exported_for_shoebox: Property to specify whether the dimension should be - exported for Shoebox. - :paramtype to_be_exported_for_shoebox: bool - """ - super().__init__(**kwargs) - self.name = name - self.display_name = display_name - self.to_be_exported_for_shoebox = to_be_exported_for_shoebox - - -class Error(_serialization.Model): - """The server error. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar code: The error code. - :vartype code: str - :ivar message: The error message. - :vartype message: str - :ivar inner_error: The inner error, contains a more specific error code. - :vartype inner_error: ~azure.mgmt.keyvault.v2021_10_01.models.Error - """ - - _validation = { - "code": {"readonly": True}, - "message": {"readonly": True}, - "inner_error": {"readonly": True}, - } - - _attribute_map = { - "code": {"key": "code", "type": "str"}, - "message": {"key": "message", "type": "str"}, - "inner_error": {"key": "innererror", "type": "Error"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.code = None - self.message = None - self.inner_error = None - - -class IPRule(_serialization.Model): - """A rule governing the accessibility of a vault from a specific ip address or ip range. - - All required parameters must be populated in order to send to server. - - :ivar value: An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP address) - or '124.56.78.0/24' (all addresses that start with 124.56.78). Required. - :vartype value: str - """ - - _validation = { - "value": {"required": True}, - } - - _attribute_map = { - "value": {"key": "value", "type": "str"}, - } - - def __init__(self, *, value: str, **kwargs: Any) -> None: - """ - :keyword value: An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP - address) or '124.56.78.0/24' (all addresses that start with 124.56.78). Required. - :paramtype value: str - """ - super().__init__(**kwargs) - self.value = value - - -class Resource(_serialization.Model): - """Key Vault resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = None - self.tags = None - - -class Key(Resource): # pylint: disable=too-many-instance-attributes - """The key resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar attributes: The attributes of the key. - :vartype attributes: ~azure.mgmt.keyvault.v2021_10_01.models.KeyAttributes - :ivar kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: "EC", - "EC-HSM", "RSA", and "RSA-HSM". - :vartype kty: str or ~azure.mgmt.keyvault.v2021_10_01.models.JsonWebKeyType - :ivar key_ops: - :vartype key_ops: list[str or ~azure.mgmt.keyvault.v2021_10_01.models.JsonWebKeyOperation] - :ivar key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. - :vartype key_size: int - :ivar curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :vartype curve_name: str or ~azure.mgmt.keyvault.v2021_10_01.models.JsonWebKeyCurveName - :ivar key_uri: The URI to retrieve the current version of the key. - :vartype key_uri: str - :ivar key_uri_with_version: The URI to retrieve the specific version of the key. - :vartype key_uri_with_version: str - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - "key_uri": {"readonly": True}, - "key_uri_with_version": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "attributes": {"key": "properties.attributes", "type": "KeyAttributes"}, - "kty": {"key": "properties.kty", "type": "str"}, - "key_ops": {"key": "properties.keyOps", "type": "[str]"}, - "key_size": {"key": "properties.keySize", "type": "int"}, - "curve_name": {"key": "properties.curveName", "type": "str"}, - "key_uri": {"key": "properties.keyUri", "type": "str"}, - "key_uri_with_version": {"key": "properties.keyUriWithVersion", "type": "str"}, - } - - def __init__( - self, - *, - attributes: Optional["_models.KeyAttributes"] = None, - kty: Optional[Union[str, "_models.JsonWebKeyType"]] = None, - key_ops: Optional[List[Union[str, "_models.JsonWebKeyOperation"]]] = None, - key_size: Optional[int] = None, - curve_name: Optional[Union[str, "_models.JsonWebKeyCurveName"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword attributes: The attributes of the key. - :paramtype attributes: ~azure.mgmt.keyvault.v2021_10_01.models.KeyAttributes - :keyword kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: - "EC", "EC-HSM", "RSA", and "RSA-HSM". - :paramtype kty: str or ~azure.mgmt.keyvault.v2021_10_01.models.JsonWebKeyType - :keyword key_ops: - :paramtype key_ops: list[str or ~azure.mgmt.keyvault.v2021_10_01.models.JsonWebKeyOperation] - :keyword key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. - :paramtype key_size: int - :keyword curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :paramtype curve_name: str or ~azure.mgmt.keyvault.v2021_10_01.models.JsonWebKeyCurveName - """ - super().__init__(**kwargs) - self.attributes = attributes - self.kty = kty - self.key_ops = key_ops - self.key_size = key_size - self.curve_name = curve_name - self.key_uri = None - self.key_uri_with_version = None - - -class KeyAttributes(_serialization.Model): - """The object attributes managed by the Azure Key Vault service. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar enabled: Determines whether or not the object is enabled. - :vartype enabled: bool - :ivar not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :vartype not_before: int - :ivar expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :vartype expires: int - :ivar created: Creation time in seconds since 1970-01-01T00:00:00Z. - :vartype created: int - :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: int - :ivar recovery_level: The deletion recovery level currently in effect for the object. If it - contains 'Purgeable', then the object can be permanently deleted by a privileged user; - otherwise, only the system can purge the object at the end of the retention interval. Known - values are: "Purgeable", "Recoverable+Purgeable", "Recoverable", and - "Recoverable+ProtectedSubscription". - :vartype recovery_level: str or ~azure.mgmt.keyvault.v2021_10_01.models.DeletionRecoveryLevel - :ivar exportable: Indicates if the private key can be exported. - :vartype exportable: bool - """ - - _validation = { - "created": {"readonly": True}, - "updated": {"readonly": True}, - "recovery_level": {"readonly": True}, - } - - _attribute_map = { - "enabled": {"key": "enabled", "type": "bool"}, - "not_before": {"key": "nbf", "type": "int"}, - "expires": {"key": "exp", "type": "int"}, - "created": {"key": "created", "type": "int"}, - "updated": {"key": "updated", "type": "int"}, - "recovery_level": {"key": "recoveryLevel", "type": "str"}, - "exportable": {"key": "exportable", "type": "bool"}, - } - - def __init__( - self, - *, - enabled: Optional[bool] = None, - not_before: Optional[int] = None, - expires: Optional[int] = None, - exportable: Optional[bool] = None, - **kwargs: Any - ) -> None: - """ - :keyword enabled: Determines whether or not the object is enabled. - :paramtype enabled: bool - :keyword not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :paramtype not_before: int - :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :paramtype expires: int - :keyword exportable: Indicates if the private key can be exported. - :paramtype exportable: bool - """ - super().__init__(**kwargs) - self.enabled = enabled - self.not_before = not_before - self.expires = expires - self.created = None - self.updated = None - self.recovery_level = None - self.exportable = exportable - - -class KeyCreateParameters(_serialization.Model): - """The parameters used to create a key. - - All required parameters must be populated in order to send to server. - - :ivar tags: The tags that will be assigned to the key. - :vartype tags: dict[str, str] - :ivar properties: The properties of the key to be created. Required. - :vartype properties: ~azure.mgmt.keyvault.v2021_10_01.models.KeyProperties - """ - - _validation = { - "properties": {"required": True}, - } - - _attribute_map = { - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "KeyProperties"}, - } - - def __init__( - self, *, properties: "_models.KeyProperties", tags: Optional[Dict[str, str]] = None, **kwargs: Any - ) -> None: - """ - :keyword tags: The tags that will be assigned to the key. - :paramtype tags: dict[str, str] - :keyword properties: The properties of the key to be created. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2021_10_01.models.KeyProperties - """ - super().__init__(**kwargs) - self.tags = tags - self.properties = properties - - -class KeyListResult(_serialization.Model): - """The page of keys. - - :ivar value: The key resources. - :vartype value: list[~azure.mgmt.keyvault.v2021_10_01.models.Key] - :ivar next_link: The URL to get the next page of keys. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Key]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Key"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The key resources. - :paramtype value: list[~azure.mgmt.keyvault.v2021_10_01.models.Key] - :keyword next_link: The URL to get the next page of keys. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class KeyProperties(_serialization.Model): - """The properties of the key. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar attributes: The attributes of the key. - :vartype attributes: ~azure.mgmt.keyvault.v2021_10_01.models.KeyAttributes - :ivar kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: "EC", - "EC-HSM", "RSA", and "RSA-HSM". - :vartype kty: str or ~azure.mgmt.keyvault.v2021_10_01.models.JsonWebKeyType - :ivar key_ops: - :vartype key_ops: list[str or ~azure.mgmt.keyvault.v2021_10_01.models.JsonWebKeyOperation] - :ivar key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. - :vartype key_size: int - :ivar curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :vartype curve_name: str or ~azure.mgmt.keyvault.v2021_10_01.models.JsonWebKeyCurveName - :ivar key_uri: The URI to retrieve the current version of the key. - :vartype key_uri: str - :ivar key_uri_with_version: The URI to retrieve the specific version of the key. - :vartype key_uri_with_version: str - """ - - _validation = { - "key_uri": {"readonly": True}, - "key_uri_with_version": {"readonly": True}, - } - - _attribute_map = { - "attributes": {"key": "attributes", "type": "KeyAttributes"}, - "kty": {"key": "kty", "type": "str"}, - "key_ops": {"key": "keyOps", "type": "[str]"}, - "key_size": {"key": "keySize", "type": "int"}, - "curve_name": {"key": "curveName", "type": "str"}, - "key_uri": {"key": "keyUri", "type": "str"}, - "key_uri_with_version": {"key": "keyUriWithVersion", "type": "str"}, - } - - def __init__( - self, - *, - attributes: Optional["_models.KeyAttributes"] = None, - kty: Optional[Union[str, "_models.JsonWebKeyType"]] = None, - key_ops: Optional[List[Union[str, "_models.JsonWebKeyOperation"]]] = None, - key_size: Optional[int] = None, - curve_name: Optional[Union[str, "_models.JsonWebKeyCurveName"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword attributes: The attributes of the key. - :paramtype attributes: ~azure.mgmt.keyvault.v2021_10_01.models.KeyAttributes - :keyword kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: - "EC", "EC-HSM", "RSA", and "RSA-HSM". - :paramtype kty: str or ~azure.mgmt.keyvault.v2021_10_01.models.JsonWebKeyType - :keyword key_ops: - :paramtype key_ops: list[str or ~azure.mgmt.keyvault.v2021_10_01.models.JsonWebKeyOperation] - :keyword key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. - :paramtype key_size: int - :keyword curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :paramtype curve_name: str or ~azure.mgmt.keyvault.v2021_10_01.models.JsonWebKeyCurveName - """ - super().__init__(**kwargs) - self.attributes = attributes - self.kty = kty - self.key_ops = key_ops - self.key_size = key_size - self.curve_name = curve_name - self.key_uri = None - self.key_uri_with_version = None - - -class LogSpecification(_serialization.Model): - """Log specification of operation. - - :ivar name: Name of log specification. - :vartype name: str - :ivar display_name: Display name of log specification. - :vartype display_name: str - :ivar blob_duration: Blob duration of specification. - :vartype blob_duration: str - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display_name": {"key": "displayName", "type": "str"}, - "blob_duration": {"key": "blobDuration", "type": "str"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display_name: Optional[str] = None, - blob_duration: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Name of log specification. - :paramtype name: str - :keyword display_name: Display name of log specification. - :paramtype display_name: str - :keyword blob_duration: Blob duration of specification. - :paramtype blob_duration: str - """ - super().__init__(**kwargs) - self.name = name - self.display_name = display_name - self.blob_duration = blob_duration - - -class ManagedHsmResource(_serialization.Model): - """Managed HSM resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The Azure Resource Manager resource ID for the managed HSM Pool. - :vartype id: str - :ivar name: The name of the managed HSM Pool. - :vartype name: str - :ivar type: The resource type of the managed HSM Pool. - :vartype type: str - :ivar location: The supported Azure location where the managed HSM Pool should be created. - :vartype location: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSku - :ivar tags: Resource tags. - :vartype tags: dict[str, str] - :ivar system_data: Metadata pertaining to creation and last modification of the key vault - resource. - :vartype system_data: ~azure.mgmt.keyvault.v2021_10_01.models.SystemData - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "system_data": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "sku": {"key": "sku", "type": "ManagedHsmSku"}, - "tags": {"key": "tags", "type": "{str}"}, - "system_data": {"key": "systemData", "type": "SystemData"}, - } - - def __init__( - self, - *, - location: Optional[str] = None, - sku: Optional["_models.ManagedHsmSku"] = None, - tags: Optional[Dict[str, str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the managed HSM Pool should be created. - :paramtype location: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSku - :keyword tags: Resource tags. - :paramtype tags: dict[str, str] - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = location - self.sku = sku - self.tags = tags - self.system_data = None - - -class ManagedHsm(ManagedHsmResource): - """Resource information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The Azure Resource Manager resource ID for the managed HSM Pool. - :vartype id: str - :ivar name: The name of the managed HSM Pool. - :vartype name: str - :ivar type: The resource type of the managed HSM Pool. - :vartype type: str - :ivar location: The supported Azure location where the managed HSM Pool should be created. - :vartype location: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSku - :ivar tags: Resource tags. - :vartype tags: dict[str, str] - :ivar system_data: Metadata pertaining to creation and last modification of the key vault - resource. - :vartype system_data: ~azure.mgmt.keyvault.v2021_10_01.models.SystemData - :ivar properties: Properties of the managed HSM. - :vartype properties: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "system_data": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "sku": {"key": "sku", "type": "ManagedHsmSku"}, - "tags": {"key": "tags", "type": "{str}"}, - "system_data": {"key": "systemData", "type": "SystemData"}, - "properties": {"key": "properties", "type": "ManagedHsmProperties"}, - } - - def __init__( - self, - *, - location: Optional[str] = None, - sku: Optional["_models.ManagedHsmSku"] = None, - tags: Optional[Dict[str, str]] = None, - properties: Optional["_models.ManagedHsmProperties"] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the managed HSM Pool should be created. - :paramtype location: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSku - :keyword tags: Resource tags. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the managed HSM. - :paramtype properties: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmProperties - """ - super().__init__(location=location, sku=sku, tags=tags, **kwargs) - self.properties = properties - - -class ManagedHsmError(_serialization.Model): - """The error exception. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar error: The server error. - :vartype error: ~azure.mgmt.keyvault.v2021_10_01.models.Error - """ - - _validation = { - "error": {"readonly": True}, - } - - _attribute_map = { - "error": {"key": "error", "type": "Error"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.error = None - - -class ManagedHsmListResult(_serialization.Model): - """List of managed HSM Pools. - - :ivar value: The list of managed HSM Pools. - :vartype value: list[~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm] - :ivar next_link: The URL to get the next set of managed HSM Pools. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[ManagedHsm]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.ManagedHsm"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of managed HSM Pools. - :paramtype value: list[~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm] - :keyword next_link: The URL to get the next set of managed HSM Pools. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class ManagedHsmProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Properties of the managed HSM Pool. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the managed HSM pool. - :vartype tenant_id: str - :ivar initial_admin_object_ids: Array of initial administrators object ids for this managed hsm - pool. - :vartype initial_admin_object_ids: list[str] - :ivar hsm_uri: The URI of the managed hsm pool for performing operations on keys. - :vartype hsm_uri: str - :ivar enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this managed HSM pool. Soft delete is enabled by default for all managed HSMs and - is immutable. - :vartype enable_soft_delete: bool - :ivar soft_delete_retention_in_days: Soft deleted data retention days. When you delete an HSM - or a key, it will remain recoverable for the configured retention period or for a default - period of 90 days. It accepts values between 7 and 90. - :vartype soft_delete_retention_in_days: int - :ivar enable_purge_protection: Property specifying whether protection against purge is enabled - for this managed HSM pool. Setting this property to true activates protection against purge for - this managed HSM pool and its content - only the Managed HSM service may initiate a hard, - irrecoverable deletion. Enabling this functionality is irreversible. - :vartype enable_purge_protection: bool - :ivar create_mode: The create mode to indicate whether the resource is being created or is - being recovered from a deleted resource. Known values are: "recover" and "default". - :vartype create_mode: str or ~azure.mgmt.keyvault.v2021_10_01.models.CreateMode - :ivar status_message: Resource Status Message. - :vartype status_message: str - :ivar provisioning_state: Provisioning state. Known values are: "Succeeded", "Provisioning", - "Failed", "Updating", "Deleting", "Activated", "SecurityDomainRestore", and "Restoring". - :vartype provisioning_state: str or ~azure.mgmt.keyvault.v2021_10_01.models.ProvisioningState - :ivar network_acls: Rules governing the accessibility of the key vault from specific network - locations. - :vartype network_acls: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMNetworkRuleSet - :ivar private_endpoint_connections: List of private endpoint connections associated with the - managed hsm pool. - :vartype private_endpoint_connections: - list[~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnectionItem] - :ivar public_network_access: Control permission to the managed HSM from public networks. Known - values are: "Enabled" and "Disabled". - :vartype public_network_access: str or - ~azure.mgmt.keyvault.v2021_10_01.models.PublicNetworkAccess - :ivar scheduled_purge_date: The scheduled purge date in UTC. - :vartype scheduled_purge_date: ~datetime.datetime - """ - - _validation = { - "hsm_uri": {"readonly": True}, - "status_message": {"readonly": True}, - "provisioning_state": {"readonly": True}, - "private_endpoint_connections": {"readonly": True}, - "scheduled_purge_date": {"readonly": True}, - } - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "initial_admin_object_ids": {"key": "initialAdminObjectIds", "type": "[str]"}, - "hsm_uri": {"key": "hsmUri", "type": "str"}, - "enable_soft_delete": {"key": "enableSoftDelete", "type": "bool"}, - "soft_delete_retention_in_days": {"key": "softDeleteRetentionInDays", "type": "int"}, - "enable_purge_protection": {"key": "enablePurgeProtection", "type": "bool"}, - "create_mode": {"key": "createMode", "type": "str"}, - "status_message": {"key": "statusMessage", "type": "str"}, - "provisioning_state": {"key": "provisioningState", "type": "str"}, - "network_acls": {"key": "networkAcls", "type": "MHSMNetworkRuleSet"}, - "private_endpoint_connections": { - "key": "privateEndpointConnections", - "type": "[MHSMPrivateEndpointConnectionItem]", - }, - "public_network_access": {"key": "publicNetworkAccess", "type": "str"}, - "scheduled_purge_date": {"key": "scheduledPurgeDate", "type": "iso-8601"}, - } - - def __init__( - self, - *, - tenant_id: Optional[str] = None, - initial_admin_object_ids: Optional[List[str]] = None, - enable_soft_delete: bool = True, - soft_delete_retention_in_days: int = 90, - enable_purge_protection: bool = True, - create_mode: Optional[Union[str, "_models.CreateMode"]] = None, - network_acls: Optional["_models.MHSMNetworkRuleSet"] = None, - public_network_access: Union[str, "_models.PublicNetworkAccess"] = "Enabled", - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the managed HSM pool. - :paramtype tenant_id: str - :keyword initial_admin_object_ids: Array of initial administrators object ids for this managed - hsm pool. - :paramtype initial_admin_object_ids: list[str] - :keyword enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this managed HSM pool. Soft delete is enabled by default for all managed HSMs and - is immutable. - :paramtype enable_soft_delete: bool - :keyword soft_delete_retention_in_days: Soft deleted data retention days. When you delete an - HSM or a key, it will remain recoverable for the configured retention period or for a default - period of 90 days. It accepts values between 7 and 90. - :paramtype soft_delete_retention_in_days: int - :keyword enable_purge_protection: Property specifying whether protection against purge is - enabled for this managed HSM pool. Setting this property to true activates protection against - purge for this managed HSM pool and its content - only the Managed HSM service may initiate a - hard, irrecoverable deletion. Enabling this functionality is irreversible. - :paramtype enable_purge_protection: bool - :keyword create_mode: The create mode to indicate whether the resource is being created or is - being recovered from a deleted resource. Known values are: "recover" and "default". - :paramtype create_mode: str or ~azure.mgmt.keyvault.v2021_10_01.models.CreateMode - :keyword network_acls: Rules governing the accessibility of the key vault from specific network - locations. - :paramtype network_acls: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMNetworkRuleSet - :keyword public_network_access: Control permission to the managed HSM from public networks. - Known values are: "Enabled" and "Disabled". - :paramtype public_network_access: str or - ~azure.mgmt.keyvault.v2021_10_01.models.PublicNetworkAccess - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.initial_admin_object_ids = initial_admin_object_ids - self.hsm_uri = None - self.enable_soft_delete = enable_soft_delete - self.soft_delete_retention_in_days = soft_delete_retention_in_days - self.enable_purge_protection = enable_purge_protection - self.create_mode = create_mode - self.status_message = None - self.provisioning_state = None - self.network_acls = network_acls - self.private_endpoint_connections = None - self.public_network_access = public_network_access - self.scheduled_purge_date = None - - -class ManagedHsmSku(_serialization.Model): - """SKU details. - - All required parameters must be populated in order to send to server. - - :ivar family: SKU Family of the managed HSM Pool. "B" - :vartype family: str or ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSkuFamily - :ivar name: SKU of the managed HSM Pool. Required. Known values are: "Standard_B1", - "Custom_B32", and "Custom_B6". - :vartype name: str or ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSkuName - """ - - _validation = { - "family": {"required": True}, - "name": {"required": True}, - } - - _attribute_map = { - "family": {"key": "family", "type": "str"}, - "name": {"key": "name", "type": "str"}, - } - - def __init__( - self, - *, - family: Union[str, "_models.ManagedHsmSkuFamily"] = "B", - name: Union[str, "_models.ManagedHsmSkuName"], - **kwargs: Any - ) -> None: - """ - :keyword family: SKU Family of the managed HSM Pool. "B" - :paramtype family: str or ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSkuFamily - :keyword name: SKU of the managed HSM Pool. Required. Known values are: "Standard_B1", - "Custom_B32", and "Custom_B6". - :paramtype name: str or ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSkuName - """ - super().__init__(**kwargs) - self.family = family - self.name = name - - -class MetricSpecification(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Metric specification of operation. - - :ivar name: Name of metric specification. - :vartype name: str - :ivar display_name: Display name of metric specification. - :vartype display_name: str - :ivar display_description: Display description of metric specification. - :vartype display_description: str - :ivar unit: The metric unit. Possible values include: 'Bytes', 'Count', 'Milliseconds'. - :vartype unit: str - :ivar aggregation_type: The metric aggregation type. Possible values include: 'Average', - 'Count', 'Total'. - :vartype aggregation_type: str - :ivar supported_aggregation_types: The supported aggregation types for the metrics. - :vartype supported_aggregation_types: list[str] - :ivar supported_time_grain_types: The supported time grain types for the metrics. - :vartype supported_time_grain_types: list[str] - :ivar lock_aggregation_type: The metric lock aggregation type. - :vartype lock_aggregation_type: str - :ivar dimensions: The dimensions of metric. - :vartype dimensions: list[~azure.mgmt.keyvault.v2021_10_01.models.DimensionProperties] - :ivar fill_gap_with_zero: Property to specify whether to fill gap with zero. - :vartype fill_gap_with_zero: bool - :ivar internal_metric_name: The internal metric name. - :vartype internal_metric_name: str - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display_name": {"key": "displayName", "type": "str"}, - "display_description": {"key": "displayDescription", "type": "str"}, - "unit": {"key": "unit", "type": "str"}, - "aggregation_type": {"key": "aggregationType", "type": "str"}, - "supported_aggregation_types": {"key": "supportedAggregationTypes", "type": "[str]"}, - "supported_time_grain_types": {"key": "supportedTimeGrainTypes", "type": "[str]"}, - "lock_aggregation_type": {"key": "lockAggregationType", "type": "str"}, - "dimensions": {"key": "dimensions", "type": "[DimensionProperties]"}, - "fill_gap_with_zero": {"key": "fillGapWithZero", "type": "bool"}, - "internal_metric_name": {"key": "internalMetricName", "type": "str"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display_name: Optional[str] = None, - display_description: Optional[str] = None, - unit: Optional[str] = None, - aggregation_type: Optional[str] = None, - supported_aggregation_types: Optional[List[str]] = None, - supported_time_grain_types: Optional[List[str]] = None, - lock_aggregation_type: Optional[str] = None, - dimensions: Optional[List["_models.DimensionProperties"]] = None, - fill_gap_with_zero: Optional[bool] = None, - internal_metric_name: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Name of metric specification. - :paramtype name: str - :keyword display_name: Display name of metric specification. - :paramtype display_name: str - :keyword display_description: Display description of metric specification. - :paramtype display_description: str - :keyword unit: The metric unit. Possible values include: 'Bytes', 'Count', 'Milliseconds'. - :paramtype unit: str - :keyword aggregation_type: The metric aggregation type. Possible values include: 'Average', - 'Count', 'Total'. - :paramtype aggregation_type: str - :keyword supported_aggregation_types: The supported aggregation types for the metrics. - :paramtype supported_aggregation_types: list[str] - :keyword supported_time_grain_types: The supported time grain types for the metrics. - :paramtype supported_time_grain_types: list[str] - :keyword lock_aggregation_type: The metric lock aggregation type. - :paramtype lock_aggregation_type: str - :keyword dimensions: The dimensions of metric. - :paramtype dimensions: list[~azure.mgmt.keyvault.v2021_10_01.models.DimensionProperties] - :keyword fill_gap_with_zero: Property to specify whether to fill gap with zero. - :paramtype fill_gap_with_zero: bool - :keyword internal_metric_name: The internal metric name. - :paramtype internal_metric_name: str - """ - super().__init__(**kwargs) - self.name = name - self.display_name = display_name - self.display_description = display_description - self.unit = unit - self.aggregation_type = aggregation_type - self.supported_aggregation_types = supported_aggregation_types - self.supported_time_grain_types = supported_time_grain_types - self.lock_aggregation_type = lock_aggregation_type - self.dimensions = dimensions - self.fill_gap_with_zero = fill_gap_with_zero - self.internal_metric_name = internal_metric_name - - -class MHSMIPRule(_serialization.Model): - """A rule governing the accessibility of a managed hsm pool from a specific ip address or ip - range. - - All required parameters must be populated in order to send to server. - - :ivar value: An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP address) - or '124.56.78.0/24' (all addresses that start with 124.56.78). Required. - :vartype value: str - """ - - _validation = { - "value": {"required": True}, - } - - _attribute_map = { - "value": {"key": "value", "type": "str"}, - } - - def __init__(self, *, value: str, **kwargs: Any) -> None: - """ - :keyword value: An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP - address) or '124.56.78.0/24' (all addresses that start with 124.56.78). Required. - :paramtype value: str - """ - super().__init__(**kwargs) - self.value = value - - -class MHSMNetworkRuleSet(_serialization.Model): - """A set of rules governing the network accessibility of a managed hsm pool. - - :ivar bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or - 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and - "None". - :vartype bypass: str or ~azure.mgmt.keyvault.v2021_10_01.models.NetworkRuleBypassOptions - :ivar default_action: The default action when no rule from ipRules and from virtualNetworkRules - match. This is only used after the bypass property has been evaluated. Known values are: - "Allow" and "Deny". - :vartype default_action: str or ~azure.mgmt.keyvault.v2021_10_01.models.NetworkRuleAction - :ivar ip_rules: The list of IP address rules. - :vartype ip_rules: list[~azure.mgmt.keyvault.v2021_10_01.models.MHSMIPRule] - :ivar virtual_network_rules: The list of virtual network rules. - :vartype virtual_network_rules: - list[~azure.mgmt.keyvault.v2021_10_01.models.MHSMVirtualNetworkRule] - """ - - _attribute_map = { - "bypass": {"key": "bypass", "type": "str"}, - "default_action": {"key": "defaultAction", "type": "str"}, - "ip_rules": {"key": "ipRules", "type": "[MHSMIPRule]"}, - "virtual_network_rules": {"key": "virtualNetworkRules", "type": "[MHSMVirtualNetworkRule]"}, - } - - def __init__( - self, - *, - bypass: Optional[Union[str, "_models.NetworkRuleBypassOptions"]] = None, - default_action: Optional[Union[str, "_models.NetworkRuleAction"]] = None, - ip_rules: Optional[List["_models.MHSMIPRule"]] = None, - virtual_network_rules: Optional[List["_models.MHSMVirtualNetworkRule"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or - 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and - "None". - :paramtype bypass: str or ~azure.mgmt.keyvault.v2021_10_01.models.NetworkRuleBypassOptions - :keyword default_action: The default action when no rule from ipRules and from - virtualNetworkRules match. This is only used after the bypass property has been evaluated. - Known values are: "Allow" and "Deny". - :paramtype default_action: str or ~azure.mgmt.keyvault.v2021_10_01.models.NetworkRuleAction - :keyword ip_rules: The list of IP address rules. - :paramtype ip_rules: list[~azure.mgmt.keyvault.v2021_10_01.models.MHSMIPRule] - :keyword virtual_network_rules: The list of virtual network rules. - :paramtype virtual_network_rules: - list[~azure.mgmt.keyvault.v2021_10_01.models.MHSMVirtualNetworkRule] - """ - super().__init__(**kwargs) - self.bypass = bypass - self.default_action = default_action - self.ip_rules = ip_rules - self.virtual_network_rules = virtual_network_rules - - -class MHSMPrivateEndpoint(_serialization.Model): - """Private endpoint object properties. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Full identifier of the private endpoint resource. - :vartype id: str - """ - - _validation = { - "id": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.id = None - - -class MHSMPrivateEndpointConnection(ManagedHsmResource): # pylint: disable=too-many-instance-attributes - """Private endpoint connection resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The Azure Resource Manager resource ID for the managed HSM Pool. - :vartype id: str - :ivar name: The name of the managed HSM Pool. - :vartype name: str - :ivar type: The resource type of the managed HSM Pool. - :vartype type: str - :ivar location: The supported Azure location where the managed HSM Pool should be created. - :vartype location: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSku - :ivar tags: Resource tags. - :vartype tags: dict[str, str] - :ivar system_data: Metadata pertaining to creation and last modification of the key vault - resource. - :vartype system_data: ~azure.mgmt.keyvault.v2021_10_01.models.SystemData - :ivar etag: Modified whenever there is a change in the state of private endpoint connection. - :vartype etag: str - :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpoint - :ivar private_link_service_connection_state: Approval state of the private link connection. - :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateLinkServiceConnectionState - :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values - are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnectionProvisioningState - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "system_data": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "sku": {"key": "sku", "type": "ManagedHsmSku"}, - "tags": {"key": "tags", "type": "{str}"}, - "system_data": {"key": "systemData", "type": "SystemData"}, - "etag": {"key": "etag", "type": "str"}, - "private_endpoint": {"key": "properties.privateEndpoint", "type": "MHSMPrivateEndpoint"}, - "private_link_service_connection_state": { - "key": "properties.privateLinkServiceConnectionState", - "type": "MHSMPrivateLinkServiceConnectionState", - }, - "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - location: Optional[str] = None, - sku: Optional["_models.ManagedHsmSku"] = None, - tags: Optional[Dict[str, str]] = None, - etag: Optional[str] = None, - private_endpoint: Optional["_models.MHSMPrivateEndpoint"] = None, - private_link_service_connection_state: Optional["_models.MHSMPrivateLinkServiceConnectionState"] = None, - provisioning_state: Optional[Union[str, "_models.PrivateEndpointConnectionProvisioningState"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the managed HSM Pool should be created. - :paramtype location: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSku - :keyword tags: Resource tags. - :paramtype tags: dict[str, str] - :keyword etag: Modified whenever there is a change in the state of private endpoint connection. - :paramtype etag: str - :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpoint - :keyword private_link_service_connection_state: Approval state of the private link connection. - :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateLinkServiceConnectionState - :keyword provisioning_state: Provisioning state of the private endpoint connection. Known - values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnectionProvisioningState - """ - super().__init__(location=location, sku=sku, tags=tags, **kwargs) - self.etag = etag - self.private_endpoint = private_endpoint - self.private_link_service_connection_state = private_link_service_connection_state - self.provisioning_state = provisioning_state - - -class MHSMPrivateEndpointConnectionItem(_serialization.Model): - """Private endpoint connection item. - - :ivar id: Id of private endpoint connection. - :vartype id: str - :ivar etag: Modified whenever there is a change in the state of private endpoint connection. - :vartype etag: str - :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpoint - :ivar private_link_service_connection_state: Approval state of the private link connection. - :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateLinkServiceConnectionState - :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values - are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnectionProvisioningState - """ - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "etag": {"key": "etag", "type": "str"}, - "private_endpoint": {"key": "properties.privateEndpoint", "type": "MHSMPrivateEndpoint"}, - "private_link_service_connection_state": { - "key": "properties.privateLinkServiceConnectionState", - "type": "MHSMPrivateLinkServiceConnectionState", - }, - "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - id: Optional[str] = None, # pylint: disable=redefined-builtin - etag: Optional[str] = None, - private_endpoint: Optional["_models.MHSMPrivateEndpoint"] = None, - private_link_service_connection_state: Optional["_models.MHSMPrivateLinkServiceConnectionState"] = None, - provisioning_state: Optional[Union[str, "_models.PrivateEndpointConnectionProvisioningState"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword id: Id of private endpoint connection. - :paramtype id: str - :keyword etag: Modified whenever there is a change in the state of private endpoint connection. - :paramtype etag: str - :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpoint - :keyword private_link_service_connection_state: Approval state of the private link connection. - :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateLinkServiceConnectionState - :keyword provisioning_state: Provisioning state of the private endpoint connection. Known - values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnectionProvisioningState - """ - super().__init__(**kwargs) - self.id = id - self.etag = etag - self.private_endpoint = private_endpoint - self.private_link_service_connection_state = private_link_service_connection_state - self.provisioning_state = provisioning_state - - -class MHSMPrivateEndpointConnectionsListResult(_serialization.Model): - """List of private endpoint connections associated with a managed HSM Pools. - - :ivar value: The private endpoint connection associated with a managed HSM Pools. - :vartype value: list[~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection] - :ivar next_link: The URL to get the next set of managed HSM Pools. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[MHSMPrivateEndpointConnection]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, - *, - value: Optional[List["_models.MHSMPrivateEndpointConnection"]] = None, - next_link: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword value: The private endpoint connection associated with a managed HSM Pools. - :paramtype value: list[~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection] - :keyword next_link: The URL to get the next set of managed HSM Pools. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class MHSMPrivateLinkResource(ManagedHsmResource): - """A private link resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The Azure Resource Manager resource ID for the managed HSM Pool. - :vartype id: str - :ivar name: The name of the managed HSM Pool. - :vartype name: str - :ivar type: The resource type of the managed HSM Pool. - :vartype type: str - :ivar location: The supported Azure location where the managed HSM Pool should be created. - :vartype location: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSku - :ivar tags: Resource tags. - :vartype tags: dict[str, str] - :ivar system_data: Metadata pertaining to creation and last modification of the key vault - resource. - :vartype system_data: ~azure.mgmt.keyvault.v2021_10_01.models.SystemData - :ivar group_id: Group identifier of private link resource. - :vartype group_id: str - :ivar required_members: Required member names of private link resource. - :vartype required_members: list[str] - :ivar required_zone_names: Required DNS zone names of the the private link resource. - :vartype required_zone_names: list[str] - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "system_data": {"readonly": True}, - "group_id": {"readonly": True}, - "required_members": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "sku": {"key": "sku", "type": "ManagedHsmSku"}, - "tags": {"key": "tags", "type": "{str}"}, - "system_data": {"key": "systemData", "type": "SystemData"}, - "group_id": {"key": "properties.groupId", "type": "str"}, - "required_members": {"key": "properties.requiredMembers", "type": "[str]"}, - "required_zone_names": {"key": "properties.requiredZoneNames", "type": "[str]"}, - } - - def __init__( - self, - *, - location: Optional[str] = None, - sku: Optional["_models.ManagedHsmSku"] = None, - tags: Optional[Dict[str, str]] = None, - required_zone_names: Optional[List[str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the managed HSM Pool should be created. - :paramtype location: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSku - :keyword tags: Resource tags. - :paramtype tags: dict[str, str] - :keyword required_zone_names: Required DNS zone names of the the private link resource. - :paramtype required_zone_names: list[str] - """ - super().__init__(location=location, sku=sku, tags=tags, **kwargs) - self.group_id = None - self.required_members = None - self.required_zone_names = required_zone_names - - -class MHSMPrivateLinkResourceListResult(_serialization.Model): - """A list of private link resources. - - :ivar value: Array of private link resources. - :vartype value: list[~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateLinkResource] - """ - - _attribute_map = { - "value": {"key": "value", "type": "[MHSMPrivateLinkResource]"}, - } - - def __init__(self, *, value: Optional[List["_models.MHSMPrivateLinkResource"]] = None, **kwargs: Any) -> None: - """ - :keyword value: Array of private link resources. - :paramtype value: list[~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateLinkResource] - """ - super().__init__(**kwargs) - self.value = value - - -class MHSMPrivateLinkServiceConnectionState(_serialization.Model): - """An object that represents the approval state of the private link connection. - - :ivar status: Indicates whether the connection has been approved, rejected or removed by the - key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :vartype status: str or - ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointServiceConnectionStatus - :ivar description: The reason for approval or rejection. - :vartype description: str - :ivar actions_required: A message indicating if changes on the service provider require any - updates on the consumer. "None" - :vartype actions_required: str or ~azure.mgmt.keyvault.v2021_10_01.models.ActionsRequired - """ - - _attribute_map = { - "status": {"key": "status", "type": "str"}, - "description": {"key": "description", "type": "str"}, - "actions_required": {"key": "actionsRequired", "type": "str"}, - } - - def __init__( - self, - *, - status: Optional[Union[str, "_models.PrivateEndpointServiceConnectionStatus"]] = None, - description: Optional[str] = None, - actions_required: Optional[Union[str, "_models.ActionsRequired"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword status: Indicates whether the connection has been approved, rejected or removed by the - key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :paramtype status: str or - ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointServiceConnectionStatus - :keyword description: The reason for approval or rejection. - :paramtype description: str - :keyword actions_required: A message indicating if changes on the service provider require any - updates on the consumer. "None" - :paramtype actions_required: str or ~azure.mgmt.keyvault.v2021_10_01.models.ActionsRequired - """ - super().__init__(**kwargs) - self.status = status - self.description = description - self.actions_required = actions_required - - -class MHSMVirtualNetworkRule(_serialization.Model): - """A rule governing the accessibility of a managed hsm pool from a specific virtual network. - - All required parameters must be populated in order to send to server. - - :ivar id: Full resource id of a vnet subnet, such as - '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. - Required. - :vartype id: str - """ - - _validation = { - "id": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - } - - def __init__(self, *, id: str, **kwargs: Any) -> None: # pylint: disable=redefined-builtin - """ - :keyword id: Full resource id of a vnet subnet, such as - '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. # pylint: disable=line-too-long - Required. - :paramtype id: str - """ - super().__init__(**kwargs) - self.id = id - - -class NetworkRuleSet(_serialization.Model): - """A set of rules governing the network accessibility of a vault. - - :ivar bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or - 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and - "None". - :vartype bypass: str or ~azure.mgmt.keyvault.v2021_10_01.models.NetworkRuleBypassOptions - :ivar default_action: The default action when no rule from ipRules and from virtualNetworkRules - match. This is only used after the bypass property has been evaluated. Known values are: - "Allow" and "Deny". - :vartype default_action: str or ~azure.mgmt.keyvault.v2021_10_01.models.NetworkRuleAction - :ivar ip_rules: The list of IP address rules. - :vartype ip_rules: list[~azure.mgmt.keyvault.v2021_10_01.models.IPRule] - :ivar virtual_network_rules: The list of virtual network rules. - :vartype virtual_network_rules: - list[~azure.mgmt.keyvault.v2021_10_01.models.VirtualNetworkRule] - """ - - _attribute_map = { - "bypass": {"key": "bypass", "type": "str"}, - "default_action": {"key": "defaultAction", "type": "str"}, - "ip_rules": {"key": "ipRules", "type": "[IPRule]"}, - "virtual_network_rules": {"key": "virtualNetworkRules", "type": "[VirtualNetworkRule]"}, - } - - def __init__( - self, - *, - bypass: Optional[Union[str, "_models.NetworkRuleBypassOptions"]] = None, - default_action: Optional[Union[str, "_models.NetworkRuleAction"]] = None, - ip_rules: Optional[List["_models.IPRule"]] = None, - virtual_network_rules: Optional[List["_models.VirtualNetworkRule"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or - 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and - "None". - :paramtype bypass: str or ~azure.mgmt.keyvault.v2021_10_01.models.NetworkRuleBypassOptions - :keyword default_action: The default action when no rule from ipRules and from - virtualNetworkRules match. This is only used after the bypass property has been evaluated. - Known values are: "Allow" and "Deny". - :paramtype default_action: str or ~azure.mgmt.keyvault.v2021_10_01.models.NetworkRuleAction - :keyword ip_rules: The list of IP address rules. - :paramtype ip_rules: list[~azure.mgmt.keyvault.v2021_10_01.models.IPRule] - :keyword virtual_network_rules: The list of virtual network rules. - :paramtype virtual_network_rules: - list[~azure.mgmt.keyvault.v2021_10_01.models.VirtualNetworkRule] - """ - super().__init__(**kwargs) - self.bypass = bypass - self.default_action = default_action - self.ip_rules = ip_rules - self.virtual_network_rules = virtual_network_rules - - -class Operation(_serialization.Model): - """Key Vault REST API operation definition. - - :ivar name: Operation name: {provider}/{resource}/{operation}. - :vartype name: str - :ivar display: Display metadata associated with the operation. - :vartype display: ~azure.mgmt.keyvault.v2021_10_01.models.OperationDisplay - :ivar origin: The origin of operations. - :vartype origin: str - :ivar is_data_action: Property to specify whether the action is a data action. - :vartype is_data_action: bool - :ivar service_specification: One property of operation, include metric specifications. - :vartype service_specification: ~azure.mgmt.keyvault.v2021_10_01.models.ServiceSpecification - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display": {"key": "display", "type": "OperationDisplay"}, - "origin": {"key": "origin", "type": "str"}, - "is_data_action": {"key": "isDataAction", "type": "bool"}, - "service_specification": {"key": "properties.serviceSpecification", "type": "ServiceSpecification"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display: Optional["_models.OperationDisplay"] = None, - origin: Optional[str] = None, - is_data_action: Optional[bool] = None, - service_specification: Optional["_models.ServiceSpecification"] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Operation name: {provider}/{resource}/{operation}. - :paramtype name: str - :keyword display: Display metadata associated with the operation. - :paramtype display: ~azure.mgmt.keyvault.v2021_10_01.models.OperationDisplay - :keyword origin: The origin of operations. - :paramtype origin: str - :keyword is_data_action: Property to specify whether the action is a data action. - :paramtype is_data_action: bool - :keyword service_specification: One property of operation, include metric specifications. - :paramtype service_specification: ~azure.mgmt.keyvault.v2021_10_01.models.ServiceSpecification - """ - super().__init__(**kwargs) - self.name = name - self.display = display - self.origin = origin - self.is_data_action = is_data_action - self.service_specification = service_specification - - -class OperationDisplay(_serialization.Model): - """Display metadata associated with the operation. - - :ivar provider: Service provider: Microsoft Key Vault. - :vartype provider: str - :ivar resource: Resource on which the operation is performed etc. - :vartype resource: str - :ivar operation: Type of operation: get, read, delete, etc. - :vartype operation: str - :ivar description: Description of operation. - :vartype description: str - """ - - _attribute_map = { - "provider": {"key": "provider", "type": "str"}, - "resource": {"key": "resource", "type": "str"}, - "operation": {"key": "operation", "type": "str"}, - "description": {"key": "description", "type": "str"}, - } - - def __init__( - self, - *, - provider: Optional[str] = None, - resource: Optional[str] = None, - operation: Optional[str] = None, - description: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword provider: Service provider: Microsoft Key Vault. - :paramtype provider: str - :keyword resource: Resource on which the operation is performed etc. - :paramtype resource: str - :keyword operation: Type of operation: get, read, delete, etc. - :paramtype operation: str - :keyword description: Description of operation. - :paramtype description: str - """ - super().__init__(**kwargs) - self.provider = provider - self.resource = resource - self.operation = operation - self.description = description - - -class OperationListResult(_serialization.Model): - """Result of the request to list Storage operations. It contains a list of operations and a URL - link to get the next set of results. - - :ivar value: List of Storage operations supported by the Storage resource provider. - :vartype value: list[~azure.mgmt.keyvault.v2021_10_01.models.Operation] - :ivar next_link: The URL to get the next set of operations. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Operation]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Operation"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: List of Storage operations supported by the Storage resource provider. - :paramtype value: list[~azure.mgmt.keyvault.v2021_10_01.models.Operation] - :keyword next_link: The URL to get the next set of operations. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class Permissions(_serialization.Model): - """Permissions the identity has for keys, secrets, certificates and storage. - - :ivar keys: Permissions to keys. - :vartype keys: list[str or ~azure.mgmt.keyvault.v2021_10_01.models.KeyPermissions] - :ivar secrets: Permissions to secrets. - :vartype secrets: list[str or ~azure.mgmt.keyvault.v2021_10_01.models.SecretPermissions] - :ivar certificates: Permissions to certificates. - :vartype certificates: list[str or - ~azure.mgmt.keyvault.v2021_10_01.models.CertificatePermissions] - :ivar storage: Permissions to storage accounts. - :vartype storage: list[str or ~azure.mgmt.keyvault.v2021_10_01.models.StoragePermissions] - """ - - _attribute_map = { - "keys": {"key": "keys", "type": "[str]"}, - "secrets": {"key": "secrets", "type": "[str]"}, - "certificates": {"key": "certificates", "type": "[str]"}, - "storage": {"key": "storage", "type": "[str]"}, - } - - def __init__( - self, - *, - keys: Optional[List[Union[str, "_models.KeyPermissions"]]] = None, - secrets: Optional[List[Union[str, "_models.SecretPermissions"]]] = None, - certificates: Optional[List[Union[str, "_models.CertificatePermissions"]]] = None, - storage: Optional[List[Union[str, "_models.StoragePermissions"]]] = None, - **kwargs: Any - ) -> None: - """ - :keyword keys: Permissions to keys. - :paramtype keys: list[str or ~azure.mgmt.keyvault.v2021_10_01.models.KeyPermissions] - :keyword secrets: Permissions to secrets. - :paramtype secrets: list[str or ~azure.mgmt.keyvault.v2021_10_01.models.SecretPermissions] - :keyword certificates: Permissions to certificates. - :paramtype certificates: list[str or - ~azure.mgmt.keyvault.v2021_10_01.models.CertificatePermissions] - :keyword storage: Permissions to storage accounts. - :paramtype storage: list[str or ~azure.mgmt.keyvault.v2021_10_01.models.StoragePermissions] - """ - super().__init__(**kwargs) - self.keys = keys - self.secrets = secrets - self.certificates = certificates - self.storage = storage - - -class PrivateEndpoint(_serialization.Model): - """Private endpoint object properties. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Full identifier of the private endpoint resource. - :vartype id: str - """ - - _validation = { - "id": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.id = None - - -class PrivateEndpointConnection(Resource): - """Private endpoint connection resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar etag: Modified whenever there is a change in the state of private endpoint connection. - :vartype etag: str - :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpoint - :ivar private_link_service_connection_state: Approval state of the private link connection. - :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_10_01.models.PrivateLinkServiceConnectionState - :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values - are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnectionProvisioningState - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "etag": {"key": "etag", "type": "str"}, - "private_endpoint": {"key": "properties.privateEndpoint", "type": "PrivateEndpoint"}, - "private_link_service_connection_state": { - "key": "properties.privateLinkServiceConnectionState", - "type": "PrivateLinkServiceConnectionState", - }, - "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - etag: Optional[str] = None, - private_endpoint: Optional["_models.PrivateEndpoint"] = None, - private_link_service_connection_state: Optional["_models.PrivateLinkServiceConnectionState"] = None, - provisioning_state: Optional[Union[str, "_models.PrivateEndpointConnectionProvisioningState"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword etag: Modified whenever there is a change in the state of private endpoint connection. - :paramtype etag: str - :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpoint - :keyword private_link_service_connection_state: Approval state of the private link connection. - :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_10_01.models.PrivateLinkServiceConnectionState - :keyword provisioning_state: Provisioning state of the private endpoint connection. Known - values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnectionProvisioningState - """ - super().__init__(**kwargs) - self.etag = etag - self.private_endpoint = private_endpoint - self.private_link_service_connection_state = private_link_service_connection_state - self.provisioning_state = provisioning_state - - -class PrivateEndpointConnectionItem(_serialization.Model): - """Private endpoint connection item. - - :ivar id: Id of private endpoint connection. - :vartype id: str - :ivar etag: Modified whenever there is a change in the state of private endpoint connection. - :vartype etag: str - :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpoint - :ivar private_link_service_connection_state: Approval state of the private link connection. - :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_10_01.models.PrivateLinkServiceConnectionState - :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values - are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnectionProvisioningState - """ - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "etag": {"key": "etag", "type": "str"}, - "private_endpoint": {"key": "properties.privateEndpoint", "type": "PrivateEndpoint"}, - "private_link_service_connection_state": { - "key": "properties.privateLinkServiceConnectionState", - "type": "PrivateLinkServiceConnectionState", - }, - "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - id: Optional[str] = None, # pylint: disable=redefined-builtin - etag: Optional[str] = None, - private_endpoint: Optional["_models.PrivateEndpoint"] = None, - private_link_service_connection_state: Optional["_models.PrivateLinkServiceConnectionState"] = None, - provisioning_state: Optional[Union[str, "_models.PrivateEndpointConnectionProvisioningState"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword id: Id of private endpoint connection. - :paramtype id: str - :keyword etag: Modified whenever there is a change in the state of private endpoint connection. - :paramtype etag: str - :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpoint - :keyword private_link_service_connection_state: Approval state of the private link connection. - :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2021_10_01.models.PrivateLinkServiceConnectionState - :keyword provisioning_state: Provisioning state of the private endpoint connection. Known - values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnectionProvisioningState - """ - super().__init__(**kwargs) - self.id = id - self.etag = etag - self.private_endpoint = private_endpoint - self.private_link_service_connection_state = private_link_service_connection_state - self.provisioning_state = provisioning_state - - -class PrivateEndpointConnectionListResult(_serialization.Model): - """List of private endpoint connections. - - :ivar value: The list of private endpoint connections. - :vartype value: list[~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection] - :ivar next_link: The URL to get the next set of private endpoint connections. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[PrivateEndpointConnection]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, - *, - value: Optional[List["_models.PrivateEndpointConnection"]] = None, - next_link: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword value: The list of private endpoint connections. - :paramtype value: list[~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection] - :keyword next_link: The URL to get the next set of private endpoint connections. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class PrivateLinkResource(Resource): - """A private link resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar group_id: Group identifier of private link resource. - :vartype group_id: str - :ivar required_members: Required member names of private link resource. - :vartype required_members: list[str] - :ivar required_zone_names: Required DNS zone names of the the private link resource. - :vartype required_zone_names: list[str] - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - "group_id": {"readonly": True}, - "required_members": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "group_id": {"key": "properties.groupId", "type": "str"}, - "required_members": {"key": "properties.requiredMembers", "type": "[str]"}, - "required_zone_names": {"key": "properties.requiredZoneNames", "type": "[str]"}, - } - - def __init__(self, *, required_zone_names: Optional[List[str]] = None, **kwargs: Any) -> None: - """ - :keyword required_zone_names: Required DNS zone names of the the private link resource. - :paramtype required_zone_names: list[str] - """ - super().__init__(**kwargs) - self.group_id = None - self.required_members = None - self.required_zone_names = required_zone_names - - -class PrivateLinkResourceListResult(_serialization.Model): - """A list of private link resources. - - :ivar value: Array of private link resources. - :vartype value: list[~azure.mgmt.keyvault.v2021_10_01.models.PrivateLinkResource] - """ - - _attribute_map = { - "value": {"key": "value", "type": "[PrivateLinkResource]"}, - } - - def __init__(self, *, value: Optional[List["_models.PrivateLinkResource"]] = None, **kwargs: Any) -> None: - """ - :keyword value: Array of private link resources. - :paramtype value: list[~azure.mgmt.keyvault.v2021_10_01.models.PrivateLinkResource] - """ - super().__init__(**kwargs) - self.value = value - - -class PrivateLinkServiceConnectionState(_serialization.Model): - """An object that represents the approval state of the private link connection. - - :ivar status: Indicates whether the connection has been approved, rejected or removed by the - key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :vartype status: str or - ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointServiceConnectionStatus - :ivar description: The reason for approval or rejection. - :vartype description: str - :ivar actions_required: A message indicating if changes on the service provider require any - updates on the consumer. "None" - :vartype actions_required: str or ~azure.mgmt.keyvault.v2021_10_01.models.ActionsRequired - """ - - _attribute_map = { - "status": {"key": "status", "type": "str"}, - "description": {"key": "description", "type": "str"}, - "actions_required": {"key": "actionsRequired", "type": "str"}, - } - - def __init__( - self, - *, - status: Optional[Union[str, "_models.PrivateEndpointServiceConnectionStatus"]] = None, - description: Optional[str] = None, - actions_required: Optional[Union[str, "_models.ActionsRequired"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword status: Indicates whether the connection has been approved, rejected or removed by the - key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :paramtype status: str or - ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointServiceConnectionStatus - :keyword description: The reason for approval or rejection. - :paramtype description: str - :keyword actions_required: A message indicating if changes on the service provider require any - updates on the consumer. "None" - :paramtype actions_required: str or ~azure.mgmt.keyvault.v2021_10_01.models.ActionsRequired - """ - super().__init__(**kwargs) - self.status = status - self.description = description - self.actions_required = actions_required - - -class ResourceListResult(_serialization.Model): - """List of vault resources. - - :ivar value: The list of vault resources. - :vartype value: list[~azure.mgmt.keyvault.v2021_10_01.models.Resource] - :ivar next_link: The URL to get the next set of vault resources. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Resource]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Resource"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of vault resources. - :paramtype value: list[~azure.mgmt.keyvault.v2021_10_01.models.Resource] - :keyword next_link: The URL to get the next set of vault resources. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class Secret(Resource): - """Resource information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar properties: Properties of the secret. Required. - :vartype properties: ~azure.mgmt.keyvault.v2021_10_01.models.SecretProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "SecretProperties"}, - } - - def __init__(self, *, properties: "_models.SecretProperties", **kwargs: Any) -> None: - """ - :keyword properties: Properties of the secret. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2021_10_01.models.SecretProperties - """ - super().__init__(**kwargs) - self.properties = properties - - -class SecretAttributes(Attributes): - """The secret management attributes. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar enabled: Determines whether the object is enabled. - :vartype enabled: bool - :ivar not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :vartype not_before: ~datetime.datetime - :ivar expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :vartype expires: ~datetime.datetime - :ivar created: Creation time in seconds since 1970-01-01T00:00:00Z. - :vartype created: ~datetime.datetime - :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: ~datetime.datetime - """ - - -class SecretCreateOrUpdateParameters(_serialization.Model): - """Parameters for creating or updating a secret. - - All required parameters must be populated in order to send to server. - - :ivar tags: The tags that will be assigned to the secret. - :vartype tags: dict[str, str] - :ivar properties: Properties of the secret. Required. - :vartype properties: ~azure.mgmt.keyvault.v2021_10_01.models.SecretProperties - """ - - _validation = { - "properties": {"required": True}, - } - - _attribute_map = { - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "SecretProperties"}, - } - - def __init__( - self, *, properties: "_models.SecretProperties", tags: Optional[Dict[str, str]] = None, **kwargs: Any - ) -> None: - """ - :keyword tags: The tags that will be assigned to the secret. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the secret. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2021_10_01.models.SecretProperties - """ - super().__init__(**kwargs) - self.tags = tags - self.properties = properties - - -class SecretListResult(_serialization.Model): - """List of secrets. - - :ivar value: The list of secrets. - :vartype value: list[~azure.mgmt.keyvault.v2021_10_01.models.Secret] - :ivar next_link: The URL to get the next set of secrets. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Secret]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Secret"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of secrets. - :paramtype value: list[~azure.mgmt.keyvault.v2021_10_01.models.Secret] - :keyword next_link: The URL to get the next set of secrets. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class SecretPatchParameters(_serialization.Model): - """Parameters for patching a secret. - - :ivar tags: The tags that will be assigned to the secret. - :vartype tags: dict[str, str] - :ivar properties: Properties of the secret. - :vartype properties: ~azure.mgmt.keyvault.v2021_10_01.models.SecretPatchProperties - """ - - _attribute_map = { - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "SecretPatchProperties"}, - } - - def __init__( - self, - *, - tags: Optional[Dict[str, str]] = None, - properties: Optional["_models.SecretPatchProperties"] = None, - **kwargs: Any - ) -> None: - """ - :keyword tags: The tags that will be assigned to the secret. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the secret. - :paramtype properties: ~azure.mgmt.keyvault.v2021_10_01.models.SecretPatchProperties - """ - super().__init__(**kwargs) - self.tags = tags - self.properties = properties - - -class SecretPatchProperties(_serialization.Model): - """Properties of the secret. - - :ivar value: The value of the secret. - :vartype value: str - :ivar content_type: The content type of the secret. - :vartype content_type: str - :ivar attributes: The attributes of the secret. - :vartype attributes: ~azure.mgmt.keyvault.v2021_10_01.models.SecretAttributes - """ - - _attribute_map = { - "value": {"key": "value", "type": "str"}, - "content_type": {"key": "contentType", "type": "str"}, - "attributes": {"key": "attributes", "type": "SecretAttributes"}, - } - - def __init__( - self, - *, - value: Optional[str] = None, - content_type: Optional[str] = None, - attributes: Optional["_models.SecretAttributes"] = None, - **kwargs: Any - ) -> None: - """ - :keyword value: The value of the secret. - :paramtype value: str - :keyword content_type: The content type of the secret. - :paramtype content_type: str - :keyword attributes: The attributes of the secret. - :paramtype attributes: ~azure.mgmt.keyvault.v2021_10_01.models.SecretAttributes - """ - super().__init__(**kwargs) - self.value = value - self.content_type = content_type - self.attributes = attributes - - -class SecretProperties(_serialization.Model): - """Properties of the secret. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar value: The value of the secret. NOTE: 'value' will never be returned from the service, as - APIs using this model are is intended for internal use in ARM deployments. Users should use the - data-plane REST service for interaction with vault secrets. - :vartype value: str - :ivar content_type: The content type of the secret. - :vartype content_type: str - :ivar attributes: The attributes of the secret. - :vartype attributes: ~azure.mgmt.keyvault.v2021_10_01.models.SecretAttributes - :ivar secret_uri: The URI to retrieve the current version of the secret. - :vartype secret_uri: str - :ivar secret_uri_with_version: The URI to retrieve the specific version of the secret. - :vartype secret_uri_with_version: str - """ - - _validation = { - "secret_uri": {"readonly": True}, - "secret_uri_with_version": {"readonly": True}, - } - - _attribute_map = { - "value": {"key": "value", "type": "str"}, - "content_type": {"key": "contentType", "type": "str"}, - "attributes": {"key": "attributes", "type": "SecretAttributes"}, - "secret_uri": {"key": "secretUri", "type": "str"}, - "secret_uri_with_version": {"key": "secretUriWithVersion", "type": "str"}, - } - - def __init__( - self, - *, - value: Optional[str] = None, - content_type: Optional[str] = None, - attributes: Optional["_models.SecretAttributes"] = None, - **kwargs: Any - ) -> None: - """ - :keyword value: The value of the secret. NOTE: 'value' will never be returned from the service, - as APIs using this model are is intended for internal use in ARM deployments. Users should use - the data-plane REST service for interaction with vault secrets. - :paramtype value: str - :keyword content_type: The content type of the secret. - :paramtype content_type: str - :keyword attributes: The attributes of the secret. - :paramtype attributes: ~azure.mgmt.keyvault.v2021_10_01.models.SecretAttributes - """ - super().__init__(**kwargs) - self.value = value - self.content_type = content_type - self.attributes = attributes - self.secret_uri = None - self.secret_uri_with_version = None - - -class ServiceSpecification(_serialization.Model): - """One property of operation, include log specifications. - - :ivar log_specifications: Log specifications of operation. - :vartype log_specifications: list[~azure.mgmt.keyvault.v2021_10_01.models.LogSpecification] - :ivar metric_specifications: Metric specifications of operation. - :vartype metric_specifications: - list[~azure.mgmt.keyvault.v2021_10_01.models.MetricSpecification] - """ - - _attribute_map = { - "log_specifications": {"key": "logSpecifications", "type": "[LogSpecification]"}, - "metric_specifications": {"key": "metricSpecifications", "type": "[MetricSpecification]"}, - } - - def __init__( - self, - *, - log_specifications: Optional[List["_models.LogSpecification"]] = None, - metric_specifications: Optional[List["_models.MetricSpecification"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword log_specifications: Log specifications of operation. - :paramtype log_specifications: list[~azure.mgmt.keyvault.v2021_10_01.models.LogSpecification] - :keyword metric_specifications: Metric specifications of operation. - :paramtype metric_specifications: - list[~azure.mgmt.keyvault.v2021_10_01.models.MetricSpecification] - """ - super().__init__(**kwargs) - self.log_specifications = log_specifications - self.metric_specifications = metric_specifications - - -class Sku(_serialization.Model): - """SKU details. - - All required parameters must be populated in order to send to server. - - :ivar family: SKU family name. "A" - :vartype family: str or ~azure.mgmt.keyvault.v2021_10_01.models.SkuFamily - :ivar name: SKU name to specify whether the key vault is a standard vault or a premium vault. - Required. Known values are: "standard" and "premium". - :vartype name: str or ~azure.mgmt.keyvault.v2021_10_01.models.SkuName - """ - - _validation = { - "family": {"required": True}, - "name": {"required": True}, - } - - _attribute_map = { - "family": {"key": "family", "type": "str"}, - "name": {"key": "name", "type": "str"}, - } - - def __init__( - self, *, family: Union[str, "_models.SkuFamily"] = "A", name: Union[str, "_models.SkuName"], **kwargs: Any - ) -> None: - """ - :keyword family: SKU family name. "A" - :paramtype family: str or ~azure.mgmt.keyvault.v2021_10_01.models.SkuFamily - :keyword name: SKU name to specify whether the key vault is a standard vault or a premium - vault. Required. Known values are: "standard" and "premium". - :paramtype name: str or ~azure.mgmt.keyvault.v2021_10_01.models.SkuName - """ - super().__init__(**kwargs) - self.family = family - self.name = name - - -class SystemData(_serialization.Model): - """Metadata pertaining to creation and last modification of the key vault resource. - - :ivar created_by: The identity that created the key vault resource. - :vartype created_by: str - :ivar created_by_type: The type of identity that created the key vault resource. Known values - are: "User", "Application", "ManagedIdentity", and "Key". - :vartype created_by_type: str or ~azure.mgmt.keyvault.v2021_10_01.models.IdentityType - :ivar created_at: The timestamp of the key vault resource creation (UTC). - :vartype created_at: ~datetime.datetime - :ivar last_modified_by: The identity that last modified the key vault resource. - :vartype last_modified_by: str - :ivar last_modified_by_type: The type of identity that last modified the key vault resource. - Known values are: "User", "Application", "ManagedIdentity", and "Key". - :vartype last_modified_by_type: str or ~azure.mgmt.keyvault.v2021_10_01.models.IdentityType - :ivar last_modified_at: The timestamp of the key vault resource last modification (UTC). - :vartype last_modified_at: ~datetime.datetime - """ - - _attribute_map = { - "created_by": {"key": "createdBy", "type": "str"}, - "created_by_type": {"key": "createdByType", "type": "str"}, - "created_at": {"key": "createdAt", "type": "iso-8601"}, - "last_modified_by": {"key": "lastModifiedBy", "type": "str"}, - "last_modified_by_type": {"key": "lastModifiedByType", "type": "str"}, - "last_modified_at": {"key": "lastModifiedAt", "type": "iso-8601"}, - } - - def __init__( - self, - *, - created_by: Optional[str] = None, - created_by_type: Optional[Union[str, "_models.IdentityType"]] = None, - created_at: Optional[datetime.datetime] = None, - last_modified_by: Optional[str] = None, - last_modified_by_type: Optional[Union[str, "_models.IdentityType"]] = None, - last_modified_at: Optional[datetime.datetime] = None, - **kwargs: Any - ) -> None: - """ - :keyword created_by: The identity that created the key vault resource. - :paramtype created_by: str - :keyword created_by_type: The type of identity that created the key vault resource. Known - values are: "User", "Application", "ManagedIdentity", and "Key". - :paramtype created_by_type: str or ~azure.mgmt.keyvault.v2021_10_01.models.IdentityType - :keyword created_at: The timestamp of the key vault resource creation (UTC). - :paramtype created_at: ~datetime.datetime - :keyword last_modified_by: The identity that last modified the key vault resource. - :paramtype last_modified_by: str - :keyword last_modified_by_type: The type of identity that last modified the key vault resource. - Known values are: "User", "Application", "ManagedIdentity", and "Key". - :paramtype last_modified_by_type: str or ~azure.mgmt.keyvault.v2021_10_01.models.IdentityType - :keyword last_modified_at: The timestamp of the key vault resource last modification (UTC). - :paramtype last_modified_at: ~datetime.datetime - """ - super().__init__(**kwargs) - self.created_by = created_by - self.created_by_type = created_by_type - self.created_at = created_at - self.last_modified_by = last_modified_by - self.last_modified_by_type = last_modified_by_type - self.last_modified_at = last_modified_at - - -class Vault(_serialization.Model): - """Resource information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar system_data: System metadata for the key vault. - :vartype system_data: ~azure.mgmt.keyvault.v2021_10_01.models.SystemData - :ivar properties: Properties of the vault. Required. - :vartype properties: ~azure.mgmt.keyvault.v2021_10_01.models.VaultProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "system_data": {"readonly": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "system_data": {"key": "systemData", "type": "SystemData"}, - "properties": {"key": "properties", "type": "VaultProperties"}, - } - - def __init__( - self, - *, - properties: "_models.VaultProperties", - location: Optional[str] = None, - tags: Optional[Dict[str, str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: Azure location of the key vault resource. - :paramtype location: str - :keyword tags: Tags assigned to the key vault resource. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the vault. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2021_10_01.models.VaultProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = location - self.tags = tags - self.system_data = None - self.properties = properties - - -class VaultAccessPolicyParameters(_serialization.Model): - """Parameters for updating the access policy in a vault. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar id: The resource id of the access policy. - :vartype id: str - :ivar name: The resource name of the access policy. - :vartype name: str - :ivar type: The resource name of the access policy. - :vartype type: str - :ivar location: The resource type of the access policy. - :vartype location: str - :ivar properties: Properties of the access policy. Required. - :vartype properties: ~azure.mgmt.keyvault.v2021_10_01.models.VaultAccessPolicyProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "properties": {"key": "properties", "type": "VaultAccessPolicyProperties"}, - } - - def __init__(self, *, properties: "_models.VaultAccessPolicyProperties", **kwargs: Any) -> None: - """ - :keyword properties: Properties of the access policy. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2021_10_01.models.VaultAccessPolicyProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = None - self.properties = properties - - -class VaultAccessPolicyProperties(_serialization.Model): - """Properties of the vault access policy. - - All required parameters must be populated in order to send to server. - - :ivar access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. Required. - :vartype access_policies: list[~azure.mgmt.keyvault.v2021_10_01.models.AccessPolicyEntry] - """ - - _validation = { - "access_policies": {"required": True}, - } - - _attribute_map = { - "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, - } - - def __init__(self, *, access_policies: List["_models.AccessPolicyEntry"], **kwargs: Any) -> None: - """ - :keyword access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. Required. - :paramtype access_policies: list[~azure.mgmt.keyvault.v2021_10_01.models.AccessPolicyEntry] - """ - super().__init__(**kwargs) - self.access_policies = access_policies - - -class VaultCheckNameAvailabilityParameters(_serialization.Model): - """The parameters used to check the availability of the vault name. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar name: The vault name. Required. - :vartype name: str - :ivar type: The type of resource, Microsoft.KeyVault/vaults. Required. Default value is - "Microsoft.KeyVault/vaults". - :vartype type: str - """ - - _validation = { - "name": {"required": True}, - "type": {"required": True, "constant": True}, - } - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - } - - type = "Microsoft.KeyVault/vaults" - - def __init__(self, *, name: str, **kwargs: Any) -> None: - """ - :keyword name: The vault name. Required. - :paramtype name: str - """ - super().__init__(**kwargs) - self.name = name - - -class VaultCreateOrUpdateParameters(_serialization.Model): - """Parameters for creating or updating a vault. - - All required parameters must be populated in order to send to server. - - :ivar location: The supported Azure location where the key vault should be created. Required. - :vartype location: str - :ivar tags: The tags that will be assigned to the key vault. - :vartype tags: dict[str, str] - :ivar properties: Properties of the vault. Required. - :vartype properties: ~azure.mgmt.keyvault.v2021_10_01.models.VaultProperties - """ - - _validation = { - "location": {"required": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "VaultProperties"}, - } - - def __init__( - self, - *, - location: str, - properties: "_models.VaultProperties", - tags: Optional[Dict[str, str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the key vault should be created. - Required. - :paramtype location: str - :keyword tags: The tags that will be assigned to the key vault. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the vault. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2021_10_01.models.VaultProperties - """ - super().__init__(**kwargs) - self.location = location - self.tags = tags - self.properties = properties - - -class VaultListResult(_serialization.Model): - """List of vaults. - - :ivar value: The list of vaults. - :vartype value: list[~azure.mgmt.keyvault.v2021_10_01.models.Vault] - :ivar next_link: The URL to get the next set of vaults. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Vault]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Vault"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of vaults. - :paramtype value: list[~azure.mgmt.keyvault.v2021_10_01.models.Vault] - :keyword next_link: The URL to get the next set of vaults. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class VaultPatchParameters(_serialization.Model): - """Parameters for creating or updating a vault. - - :ivar tags: The tags that will be assigned to the key vault. - :vartype tags: dict[str, str] - :ivar properties: Properties of the vault. - :vartype properties: ~azure.mgmt.keyvault.v2021_10_01.models.VaultPatchProperties - """ - - _attribute_map = { - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "VaultPatchProperties"}, - } - - def __init__( - self, - *, - tags: Optional[Dict[str, str]] = None, - properties: Optional["_models.VaultPatchProperties"] = None, - **kwargs: Any - ) -> None: - """ - :keyword tags: The tags that will be assigned to the key vault. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the vault. - :paramtype properties: ~azure.mgmt.keyvault.v2021_10_01.models.VaultPatchProperties - """ - super().__init__(**kwargs) - self.tags = tags - self.properties = properties - - -class VaultPatchProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Properties of the vault. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. - :vartype tenant_id: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2021_10_01.models.Sku - :ivar access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. - :vartype access_policies: list[~azure.mgmt.keyvault.v2021_10_01.models.AccessPolicyEntry] - :ivar enabled_for_deployment: Property to specify whether Azure Virtual Machines are permitted - to retrieve certificates stored as secrets from the key vault. - :vartype enabled_for_deployment: bool - :ivar enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :vartype enabled_for_disk_encryption: bool - :ivar enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :vartype enabled_for_template_deployment: bool - :ivar enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. Once set to true, it cannot be reverted to false. - :vartype enable_soft_delete: bool - :ivar enable_rbac_authorization: Property that controls how data actions are authorized. When - true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored. When false, - the key vault will use the access policies specified in vault properties, and any policy stored - on Azure Resource Manager will be ignored. If null or not specified, the value of this property - will not change. - :vartype enable_rbac_authorization: bool - :ivar soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and <=90. - :vartype soft_delete_retention_in_days: int - :ivar create_mode: The vault's create mode to indicate whether the vault need to be recovered - or not. Known values are: "recover" and "default". - :vartype create_mode: str or ~azure.mgmt.keyvault.v2021_10_01.models.CreateMode - :ivar enable_purge_protection: Property specifying whether protection against purge is enabled - for this vault. Setting this property to true activates protection against purge for this vault - and its content - only the Key Vault service may initiate a hard, irrecoverable deletion. The - setting is effective only if soft delete is also enabled. Enabling this functionality is - irreversible - that is, the property does not accept false as its value. - :vartype enable_purge_protection: bool - :ivar network_acls: A collection of rules governing the accessibility of the vault from - specific network locations. - :vartype network_acls: ~azure.mgmt.keyvault.v2021_10_01.models.NetworkRuleSet - :ivar public_network_access: Property to specify whether the vault will accept traffic from - public internet. If set to 'disabled' all traffic except private endpoint traffic and that that - originates from trusted services will be blocked. This will override the set firewall rules, - meaning that even if the firewall rules are present we will not honor the rules. - :vartype public_network_access: str - """ - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "sku": {"key": "sku", "type": "Sku"}, - "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, - "enabled_for_deployment": {"key": "enabledForDeployment", "type": "bool"}, - "enabled_for_disk_encryption": {"key": "enabledForDiskEncryption", "type": "bool"}, - "enabled_for_template_deployment": {"key": "enabledForTemplateDeployment", "type": "bool"}, - "enable_soft_delete": {"key": "enableSoftDelete", "type": "bool"}, - "enable_rbac_authorization": {"key": "enableRbacAuthorization", "type": "bool"}, - "soft_delete_retention_in_days": {"key": "softDeleteRetentionInDays", "type": "int"}, - "create_mode": {"key": "createMode", "type": "str"}, - "enable_purge_protection": {"key": "enablePurgeProtection", "type": "bool"}, - "network_acls": {"key": "networkAcls", "type": "NetworkRuleSet"}, - "public_network_access": {"key": "publicNetworkAccess", "type": "str"}, - } - - def __init__( - self, - *, - tenant_id: Optional[str] = None, - sku: Optional["_models.Sku"] = None, - access_policies: Optional[List["_models.AccessPolicyEntry"]] = None, - enabled_for_deployment: Optional[bool] = None, - enabled_for_disk_encryption: Optional[bool] = None, - enabled_for_template_deployment: Optional[bool] = None, - enable_soft_delete: Optional[bool] = None, - enable_rbac_authorization: Optional[bool] = None, - soft_delete_retention_in_days: Optional[int] = None, - create_mode: Optional[Union[str, "_models.CreateMode"]] = None, - enable_purge_protection: Optional[bool] = None, - network_acls: Optional["_models.NetworkRuleSet"] = None, - public_network_access: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. - :paramtype tenant_id: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2021_10_01.models.Sku - :keyword access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. - :paramtype access_policies: list[~azure.mgmt.keyvault.v2021_10_01.models.AccessPolicyEntry] - :keyword enabled_for_deployment: Property to specify whether Azure Virtual Machines are - permitted to retrieve certificates stored as secrets from the key vault. - :paramtype enabled_for_deployment: bool - :keyword enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :paramtype enabled_for_disk_encryption: bool - :keyword enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :paramtype enabled_for_template_deployment: bool - :keyword enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. Once set to true, it cannot be reverted to false. - :paramtype enable_soft_delete: bool - :keyword enable_rbac_authorization: Property that controls how data actions are authorized. - When true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored. When false, - the key vault will use the access policies specified in vault properties, and any policy stored - on Azure Resource Manager will be ignored. If null or not specified, the value of this property - will not change. - :paramtype enable_rbac_authorization: bool - :keyword soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and - <=90. - :paramtype soft_delete_retention_in_days: int - :keyword create_mode: The vault's create mode to indicate whether the vault need to be - recovered or not. Known values are: "recover" and "default". - :paramtype create_mode: str or ~azure.mgmt.keyvault.v2021_10_01.models.CreateMode - :keyword enable_purge_protection: Property specifying whether protection against purge is - enabled for this vault. Setting this property to true activates protection against purge for - this vault and its content - only the Key Vault service may initiate a hard, irrecoverable - deletion. The setting is effective only if soft delete is also enabled. Enabling this - functionality is irreversible - that is, the property does not accept false as its value. - :paramtype enable_purge_protection: bool - :keyword network_acls: A collection of rules governing the accessibility of the vault from - specific network locations. - :paramtype network_acls: ~azure.mgmt.keyvault.v2021_10_01.models.NetworkRuleSet - :keyword public_network_access: Property to specify whether the vault will accept traffic from - public internet. If set to 'disabled' all traffic except private endpoint traffic and that that - originates from trusted services will be blocked. This will override the set firewall rules, - meaning that even if the firewall rules are present we will not honor the rules. - :paramtype public_network_access: str - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.sku = sku - self.access_policies = access_policies - self.enabled_for_deployment = enabled_for_deployment - self.enabled_for_disk_encryption = enabled_for_disk_encryption - self.enabled_for_template_deployment = enabled_for_template_deployment - self.enable_soft_delete = enable_soft_delete - self.enable_rbac_authorization = enable_rbac_authorization - self.soft_delete_retention_in_days = soft_delete_retention_in_days - self.create_mode = create_mode - self.enable_purge_protection = enable_purge_protection - self.network_acls = network_acls - self.public_network_access = public_network_access - - -class VaultProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Properties of the vault. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :vartype tenant_id: str - :ivar sku: SKU details. Required. - :vartype sku: ~azure.mgmt.keyvault.v2021_10_01.models.Sku - :ivar access_policies: An array of 0 to 1024 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. When - ``createMode`` is set to ``recover``\\ , access policies are not required. Otherwise, access - policies are required. - :vartype access_policies: list[~azure.mgmt.keyvault.v2021_10_01.models.AccessPolicyEntry] - :ivar vault_uri: The URI of the vault for performing operations on keys and secrets. - :vartype vault_uri: str - :ivar hsm_pool_resource_id: The resource id of HSM Pool. - :vartype hsm_pool_resource_id: str - :ivar enabled_for_deployment: Property to specify whether Azure Virtual Machines are permitted - to retrieve certificates stored as secrets from the key vault. - :vartype enabled_for_deployment: bool - :ivar enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :vartype enabled_for_disk_encryption: bool - :ivar enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :vartype enabled_for_template_deployment: bool - :ivar enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. If it's not set to any value(true or false) when creating new key - vault, it will be set to true by default. Once set to true, it cannot be reverted to false. - :vartype enable_soft_delete: bool - :ivar soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and <=90. - :vartype soft_delete_retention_in_days: int - :ivar enable_rbac_authorization: Property that controls how data actions are authorized. When - true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored. When false, - the key vault will use the access policies specified in vault properties, and any policy stored - on Azure Resource Manager will be ignored. If null or not specified, the vault is created with - the default value of false. Note that management actions are always authorized with RBAC. - :vartype enable_rbac_authorization: bool - :ivar create_mode: The vault's create mode to indicate whether the vault need to be recovered - or not. Known values are: "recover" and "default". - :vartype create_mode: str or ~azure.mgmt.keyvault.v2021_10_01.models.CreateMode - :ivar enable_purge_protection: Property specifying whether protection against purge is enabled - for this vault. Setting this property to true activates protection against purge for this vault - and its content - only the Key Vault service may initiate a hard, irrecoverable deletion. The - setting is effective only if soft delete is also enabled. Enabling this functionality is - irreversible - that is, the property does not accept false as its value. - :vartype enable_purge_protection: bool - :ivar network_acls: Rules governing the accessibility of the key vault from specific network - locations. - :vartype network_acls: ~azure.mgmt.keyvault.v2021_10_01.models.NetworkRuleSet - :ivar provisioning_state: Provisioning state of the vault. Known values are: "Succeeded" and - "RegisteringDns". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_10_01.models.VaultProvisioningState - :ivar private_endpoint_connections: List of private endpoint connections associated with the - key vault. - :vartype private_endpoint_connections: - list[~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnectionItem] - :ivar public_network_access: Property to specify whether the vault will accept traffic from - public internet. If set to 'disabled' all traffic except private endpoint traffic and that that - originates from trusted services will be blocked. This will override the set firewall rules, - meaning that even if the firewall rules are present we will not honor the rules. - :vartype public_network_access: str - """ - - _validation = { - "tenant_id": {"required": True}, - "sku": {"required": True}, - "hsm_pool_resource_id": {"readonly": True}, - "private_endpoint_connections": {"readonly": True}, - } - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "sku": {"key": "sku", "type": "Sku"}, - "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, - "vault_uri": {"key": "vaultUri", "type": "str"}, - "hsm_pool_resource_id": {"key": "hsmPoolResourceId", "type": "str"}, - "enabled_for_deployment": {"key": "enabledForDeployment", "type": "bool"}, - "enabled_for_disk_encryption": {"key": "enabledForDiskEncryption", "type": "bool"}, - "enabled_for_template_deployment": {"key": "enabledForTemplateDeployment", "type": "bool"}, - "enable_soft_delete": {"key": "enableSoftDelete", "type": "bool"}, - "soft_delete_retention_in_days": {"key": "softDeleteRetentionInDays", "type": "int"}, - "enable_rbac_authorization": {"key": "enableRbacAuthorization", "type": "bool"}, - "create_mode": {"key": "createMode", "type": "str"}, - "enable_purge_protection": {"key": "enablePurgeProtection", "type": "bool"}, - "network_acls": {"key": "networkAcls", "type": "NetworkRuleSet"}, - "provisioning_state": {"key": "provisioningState", "type": "str"}, - "private_endpoint_connections": { - "key": "privateEndpointConnections", - "type": "[PrivateEndpointConnectionItem]", - }, - "public_network_access": {"key": "publicNetworkAccess", "type": "str"}, - } - - def __init__( - self, - *, - tenant_id: str, - sku: "_models.Sku", - access_policies: Optional[List["_models.AccessPolicyEntry"]] = None, - vault_uri: Optional[str] = None, - enabled_for_deployment: Optional[bool] = None, - enabled_for_disk_encryption: Optional[bool] = None, - enabled_for_template_deployment: Optional[bool] = None, - enable_soft_delete: bool = True, - soft_delete_retention_in_days: int = 90, - enable_rbac_authorization: bool = False, - create_mode: Optional[Union[str, "_models.CreateMode"]] = None, - enable_purge_protection: Optional[bool] = None, - network_acls: Optional["_models.NetworkRuleSet"] = None, - provisioning_state: Optional[Union[str, "_models.VaultProvisioningState"]] = None, - public_network_access: str = "enabled", - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :paramtype tenant_id: str - :keyword sku: SKU details. Required. - :paramtype sku: ~azure.mgmt.keyvault.v2021_10_01.models.Sku - :keyword access_policies: An array of 0 to 1024 identities that have access to the key vault. - All identities in the array must use the same tenant ID as the key vault's tenant ID. When - ``createMode`` is set to ``recover``\\ , access policies are not required. Otherwise, access - policies are required. - :paramtype access_policies: list[~azure.mgmt.keyvault.v2021_10_01.models.AccessPolicyEntry] - :keyword vault_uri: The URI of the vault for performing operations on keys and secrets. - :paramtype vault_uri: str - :keyword enabled_for_deployment: Property to specify whether Azure Virtual Machines are - permitted to retrieve certificates stored as secrets from the key vault. - :paramtype enabled_for_deployment: bool - :keyword enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :paramtype enabled_for_disk_encryption: bool - :keyword enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :paramtype enabled_for_template_deployment: bool - :keyword enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. If it's not set to any value(true or false) when creating new key - vault, it will be set to true by default. Once set to true, it cannot be reverted to false. - :paramtype enable_soft_delete: bool - :keyword soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and - <=90. - :paramtype soft_delete_retention_in_days: int - :keyword enable_rbac_authorization: Property that controls how data actions are authorized. - When true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored. When false, - the key vault will use the access policies specified in vault properties, and any policy stored - on Azure Resource Manager will be ignored. If null or not specified, the vault is created with - the default value of false. Note that management actions are always authorized with RBAC. - :paramtype enable_rbac_authorization: bool - :keyword create_mode: The vault's create mode to indicate whether the vault need to be - recovered or not. Known values are: "recover" and "default". - :paramtype create_mode: str or ~azure.mgmt.keyvault.v2021_10_01.models.CreateMode - :keyword enable_purge_protection: Property specifying whether protection against purge is - enabled for this vault. Setting this property to true activates protection against purge for - this vault and its content - only the Key Vault service may initiate a hard, irrecoverable - deletion. The setting is effective only if soft delete is also enabled. Enabling this - functionality is irreversible - that is, the property does not accept false as its value. - :paramtype enable_purge_protection: bool - :keyword network_acls: Rules governing the accessibility of the key vault from specific network - locations. - :paramtype network_acls: ~azure.mgmt.keyvault.v2021_10_01.models.NetworkRuleSet - :keyword provisioning_state: Provisioning state of the vault. Known values are: "Succeeded" and - "RegisteringDns". - :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2021_10_01.models.VaultProvisioningState - :keyword public_network_access: Property to specify whether the vault will accept traffic from - public internet. If set to 'disabled' all traffic except private endpoint traffic and that that - originates from trusted services will be blocked. This will override the set firewall rules, - meaning that even if the firewall rules are present we will not honor the rules. - :paramtype public_network_access: str - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.sku = sku - self.access_policies = access_policies - self.vault_uri = vault_uri - self.hsm_pool_resource_id = None - self.enabled_for_deployment = enabled_for_deployment - self.enabled_for_disk_encryption = enabled_for_disk_encryption - self.enabled_for_template_deployment = enabled_for_template_deployment - self.enable_soft_delete = enable_soft_delete - self.soft_delete_retention_in_days = soft_delete_retention_in_days - self.enable_rbac_authorization = enable_rbac_authorization - self.create_mode = create_mode - self.enable_purge_protection = enable_purge_protection - self.network_acls = network_acls - self.provisioning_state = provisioning_state - self.private_endpoint_connections = None - self.public_network_access = public_network_access - - -class VirtualNetworkRule(_serialization.Model): - """A rule governing the accessibility of a vault from a specific virtual network. - - All required parameters must be populated in order to send to server. - - :ivar id: Full resource id of a vnet subnet, such as - '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. - Required. - :vartype id: str - :ivar ignore_missing_vnet_service_endpoint: Property to specify whether NRP will ignore the - check if parent subnet has serviceEndpoints configured. - :vartype ignore_missing_vnet_service_endpoint: bool - """ - - _validation = { - "id": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "ignore_missing_vnet_service_endpoint": {"key": "ignoreMissingVnetServiceEndpoint", "type": "bool"}, - } - - def __init__( - self, - *, - id: str, # pylint: disable=redefined-builtin - ignore_missing_vnet_service_endpoint: Optional[bool] = None, - **kwargs: Any - ) -> None: - """ - :keyword id: Full resource id of a vnet subnet, such as - '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. # pylint: disable=line-too-long - Required. - :paramtype id: str - :keyword ignore_missing_vnet_service_endpoint: Property to specify whether NRP will ignore the - check if parent subnet has serviceEndpoints configured. - :paramtype ignore_missing_vnet_service_endpoint: bool - """ - super().__init__(**kwargs) - self.id = id - self.ignore_missing_vnet_service_endpoint = ignore_missing_vnet_service_endpoint diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/models/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/models/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/models/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/__init__.py deleted file mode 100644 index 224be3f73e55..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/__init__.py +++ /dev/null @@ -1,35 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._keys_operations import KeysOperations -from ._vaults_operations import VaultsOperations -from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations -from ._private_link_resources_operations import PrivateLinkResourcesOperations -from ._managed_hsms_operations import ManagedHsmsOperations -from ._mhsm_private_endpoint_connections_operations import MHSMPrivateEndpointConnectionsOperations -from ._mhsm_private_link_resources_operations import MHSMPrivateLinkResourcesOperations -from ._operations import Operations -from ._secrets_operations import SecretsOperations - -from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "KeysOperations", - "VaultsOperations", - "PrivateEndpointConnectionsOperations", - "PrivateLinkResourcesOperations", - "ManagedHsmsOperations", - "MHSMPrivateEndpointConnectionsOperations", - "MHSMPrivateLinkResourcesOperations", - "Operations", - "SecretsOperations", -] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_keys_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_keys_operations.py deleted file mode 100644 index a00f136aa09b..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_keys_operations.py +++ /dev/null @@ -1,664 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Optional, Type, TypeVar, Union, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_if_not_exist_request( - resource_group_name: str, vault_name: str, key_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "keyName": _SERIALIZER.url("key_name", key_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request( - resource_group_name: str, vault_name: str, key_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "keyName": _SERIALIZER.url("key_name", key_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_version_request( - resource_group_name: str, vault_name: str, key_name: str, key_version: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "keyName": _SERIALIZER.url("key_name", key_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - "keyVersion": _SERIALIZER.url("key_version", key_version, "str", pattern=r"^[a-fA-F0-9]{32}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_versions_request( - resource_group_name: str, vault_name: str, key_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "keyName": _SERIALIZER.url("key_name", key_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class KeysOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_10_01.KeyVaultManagementClient`'s - :attr:`keys` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @overload - def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: _models.KeyCreateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. The value you provide may be copied - globally for the purpose of running the service. The value provided should not include - personally identifiable or sensitive information. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.KeyCreateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. The value you provide may be copied - globally for the purpose of running the service. The value provided should not include - personally identifiable or sensitive information. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: Union[_models.KeyCreateParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. The value you provide may be copied - globally for the purpose of running the service. The value provided should not include - personally identifiable or sensitive information. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Is either a - KeyCreateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.KeyCreateParameters or IO[bytes] - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "KeyCreateParameters") - - _request = build_create_if_not_exist_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def get(self, resource_group_name: str, vault_name: str, key_name: str, **kwargs: Any) -> _models.Key: - """Gets the current version of the specified key from the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key to be retrieved. Required. - :type vault_name: str - :param key_name: The name of the key to be retrieved. Required. - :type key_name: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> Iterable["_models.Key"]: - """Lists the keys in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the keys to be retrieved. Required. - :type vault_name: str - :return: An iterator like instance of either Key or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.Key] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("KeyListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def get_version( - self, resource_group_name: str, vault_name: str, key_name: str, key_version: str, **kwargs: Any - ) -> _models.Key: - """Gets the specified version of the specified key in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key version to be retrieved. - Required. - :type vault_name: str - :param key_name: The name of the key version to be retrieved. Required. - :type key_name: str - :param key_version: The version of the key to be retrieved. Required. - :type key_version: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - _request = build_get_version_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - key_version=key_version, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_versions( - self, resource_group_name: str, vault_name: str, key_name: str, **kwargs: Any - ) -> Iterable["_models.Key"]: - """Lists the versions of the specified key in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key versions to be retrieved. - Required. - :type vault_name: str - :param key_name: The name of the key versions to be retrieved. Required. - :type key_name: str - :return: An iterator like instance of either Key or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.Key] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_versions_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("KeyListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_managed_hsms_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_managed_hsms_operations.py deleted file mode 100644 index a6c98a8b83fa..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_managed_hsms_operations.py +++ /dev/null @@ -1,1257 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_or_update_request( - resource_group_name: str, name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_request(resource_group_name: str, name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request(resource_group_name: str, name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request(resource_group_name: str, name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_resource_group_request( - resource_group_name: str, subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_subscription_request( - subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_deleted_request(subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedManagedHSMs") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_deleted_request(name: str, location: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "name": _SERIALIZER.url("name", name, "str"), - "location": _SERIALIZER.url("location", location, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_purge_deleted_request(name: str, location: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge", - ) # pylint: disable=line-too-long - path_format_arguments = { - "name": _SERIALIZER.url("name", name, "str"), - "location": _SERIALIZER.url("location", location, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -class ManagedHsmsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_10_01.KeyVaultManagementClient`'s - :attr:`managed_hsms` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - def _create_or_update_initial( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "ManagedHsm") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def begin_create_or_update( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Is either a ManagedHsm - type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm or IO[bytes] - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._create_or_update_initial( - resource_group_name=resource_group_name, - name=name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.ManagedHsm].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.ManagedHsm]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - def _update_initial( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "ManagedHsm") - - _request = build_update_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @overload - def begin_update( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_update( - self, - resource_group_name: str, - name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def begin_update( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Is either a ManagedHsm type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm or IO[bytes] - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._update_initial( - resource_group_name=resource_group_name, - name=name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.ManagedHsm].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.ManagedHsm]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - def _delete_initial(self, resource_group_name: str, name: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_delete(self, resource_group_name: str, name: str, **kwargs: Any) -> LROPoller[None]: - """Deletes the specified managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: The name of the managed HSM Pool to delete. Required. - :type name: str - :return: An instance of LROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._delete_initial( - resource_group_name=resource_group_name, - name=name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def get(self, resource_group_name: str, name: str, **kwargs: Any) -> Optional[_models.ManagedHsm]: - """Gets the specified managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: The name of the managed HSM Pool. Required. - :type name: str - :return: ManagedHsm or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm or None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[Optional[_models.ManagedHsm]] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> Iterable["_models.ManagedHsm"]: - """The List operation gets information about the managed HSM Pools associated with the - subscription and within the specified resource group. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.ManagedHsm"]: - """The List operation gets information about the managed HSM Pools associated with the - subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedManagedHsm"]: - """The List operation gets information about the deleted managed HSMs associated with the - subscription. - - :return: An iterator like instance of either DeletedManagedHsm or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.DeletedManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.DeletedManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("DeletedManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def get_deleted(self, name: str, location: str, **kwargs: Any) -> _models.DeletedManagedHsm: - """Gets the specified deleted managed HSM. - - :param name: The name of the deleted managed HSM. Required. - :type name: str - :param location: The location of the deleted managed HSM. Required. - :type location: str - :return: DeletedManagedHsm or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.DeletedManagedHsm - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.DeletedManagedHsm] = kwargs.pop("cls", None) - - _request = build_get_deleted_request( - name=name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = self._deserialize("DeletedManagedHsm", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_purge_deleted_request( - name=name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_purge_deleted(self, name: str, location: str, **kwargs: Any) -> LROPoller[None]: - """Permanently deletes the specified managed HSM. - - :param name: The name of the soft-deleted managed HSM. Required. - :type name: str - :param location: The location of the soft-deleted managed HSM. Required. - :type location: str - :return: An instance of LROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._purge_deleted_initial( - name=name, - location=location, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_mhsm_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_mhsm_private_endpoint_connections_operations.py deleted file mode 100644 index 615cc5a3bd93..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_mhsm_private_endpoint_connections_operations.py +++ /dev/null @@ -1,621 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_by_resource_request( - resource_group_name: str, name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request( - resource_group_name: str, name: str, private_endpoint_connection_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_put_request( - resource_group_name: str, name: str, private_endpoint_connection_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request( - resource_group_name: str, name: str, private_endpoint_connection_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -class MHSMPrivateEndpointConnectionsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_10_01.KeyVaultManagementClient`'s - :attr:`mhsm_private_endpoint_connections` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list_by_resource( - self, resource_group_name: str, name: str, **kwargs: Any - ) -> Iterable["_models.MHSMPrivateEndpointConnection"]: - """The List operation gets information about the private endpoint connections associated with the - managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :return: An iterator like instance of either MHSMPrivateEndpointConnection or the result of - cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("MHSMPrivateEndpointConnectionsListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def get( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Gets the specified private endpoint connection associated with the managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: _models.MHSMPrivateEndpointConnection, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: Union[_models.MHSMPrivateEndpointConnection, IO[bytes]], - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Is either a - MHSMPrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection or - IO[bytes] - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _json = self._serialize.body(properties, "MHSMPrivateEndpointConnection") - - _request = build_put_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Azure-AsyncOperation"] = self._deserialize( - "str", response.headers.get("Azure-AsyncOperation") - ) - - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - def _delete_initial( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_delete( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> LROPoller[_models.MHSMPrivateEndpointConnection]: - """Deletes the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :return: An instance of LROPoller that returns either MHSMPrivateEndpointConnection or the - result of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._delete_initial( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.MHSMPrivateEndpointConnection].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.MHSMPrivateEndpointConnection]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_mhsm_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_mhsm_private_link_resources_operations.py deleted file mode 100644 index 00df9aa91832..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_mhsm_private_link_resources_operations.py +++ /dev/null @@ -1,146 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_by_mhsm_resource_request( - resource_group_name: str, name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateLinkResources", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class MHSMPrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_10_01.KeyVaultManagementClient`'s - :attr:`mhsm_private_link_resources` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list_by_mhsm_resource( - self, resource_group_name: str, name: str, **kwargs: Any - ) -> _models.MHSMPrivateLinkResourceListResult: - """Gets the private link resources supported for the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :return: MHSMPrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateLinkResourceListResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.MHSMPrivateLinkResourceListResult] = kwargs.pop("cls", None) - - _request = build_list_by_mhsm_resource_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("MHSMPrivateLinkResourceListResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_patch.py deleted file mode 100644 index 2badf5aafe89..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_patch.py +++ /dev/null @@ -1,134 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -import sys -from typing import Any, List, Iterable, Optional, Type -import urllib.parse - -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.rest import HttpRequest -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ._vaults_operations import VaultsOperations as _VaultsOperations, ClsType, build_list_request -from .. import models as _models - -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports - -class VaultsOperations(_VaultsOperations): - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - -__all__: List[str] = ["VaultsOperations"] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_private_endpoint_connections_operations.py deleted file mode 100644 index 65330873e921..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_private_endpoint_connections_operations.py +++ /dev/null @@ -1,627 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_get_request( - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_put_request( - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request( - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_resource_request( - resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class PrivateEndpointConnectionsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_10_01.KeyVaultManagementClient`'s - :attr:`private_endpoint_connections` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def get( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Optional[_models.PrivateEndpointConnection]: - """Gets the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: PrivateEndpointConnection or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection or None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[Optional[_models.PrivateEndpointConnection]] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: _models.PrivateEndpointConnection, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: Union[_models.PrivateEndpointConnection, IO[bytes]], - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Is either a - PrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection or - IO[bytes] - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _json = self._serialize.body(properties, "PrivateEndpointConnection") - - _request = build_put_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Azure-AsyncOperation"] = self._deserialize( - "str", response.headers.get("Azure-AsyncOperation") - ) - - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - def _delete_initial( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_delete( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> LROPoller[_models.PrivateEndpointConnection]: - """Deletes the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: An instance of LROPoller that returns either PrivateEndpointConnection or the result - of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._delete_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.PrivateEndpointConnection].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.PrivateEndpointConnection]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @distributed_trace - def list_by_resource( - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> Iterable["_models.PrivateEndpointConnection"]: - """The List operation gets information about the private endpoint connections associated with the - vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :return: An iterator like instance of either PrivateEndpointConnection or the result of - cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.PrivateEndpointConnectionListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("PrivateEndpointConnectionListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_secrets_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_secrets_operations.py deleted file mode 100644 index 1fe7769c14d4..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_secrets_operations.py +++ /dev/null @@ -1,650 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Optional, Type, TypeVar, Union, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_or_update_request( - resource_group_name: str, vault_name: str, secret_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "secretName": _SERIALIZER.url("secret_name", secret_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_request( - resource_group_name: str, vault_name: str, secret_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "secretName": _SERIALIZER.url("secret_name", secret_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request( - resource_group_name: str, vault_name: str, secret_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "secretName": _SERIALIZER.url("secret_name", secret_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_request( - resource_group_name: str, vault_name: str, subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class SecretsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_10_01.KeyVaultManagementClient`'s - :attr:`secrets` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @overload - def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: _models.SecretCreateOrUpdateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. The value you provide may be copied globally for the - purpose of running the service. The value provided should not include personally identifiable - or sensitive information. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.SecretCreateOrUpdateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. The value you provide may be copied globally for the - purpose of running the service. The value provided should not include personally identifiable - or sensitive information. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: Union[_models.SecretCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. The value you provide may be copied globally for the - purpose of running the service. The value provided should not include personally identifiable - or sensitive information. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Is either a - SecretCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.SecretCreateOrUpdateParameters or - IO[bytes] - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "SecretCreateOrUpdateParameters") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: _models.SecretPatchParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.SecretPatchParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: Union[_models.SecretPatchParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Is either a SecretPatchParameters type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.SecretPatchParameters or IO[bytes] - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "SecretPatchParameters") - - _request = build_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def get(self, resource_group_name: str, vault_name: str, secret_name: str, **kwargs: Any) -> _models.Secret: - """Gets the specified secret. NOTE: This API is intended for internal use in ARM deployments. - Users should use the data-plane REST service for interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param secret_name: The name of the secret. Required. - :type secret_name: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list( - self, resource_group_name: str, vault_name: str, top: Optional[int] = None, **kwargs: Any - ) -> Iterable["_models.Secret"]: - """The List operation gets information about the secrets in a vault. NOTE: This API is intended - for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Secret or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.Secret] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) - cls: ClsType[_models.SecretListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("SecretListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/py.typed b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/py.typed deleted file mode 100644 index e5aff4f83af8..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/py.typed +++ /dev/null @@ -1 +0,0 @@ -# Marker file for PEP 561. \ No newline at end of file diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/__init__.py deleted file mode 100644 index 6bb4b7c63a45..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/__init__.py +++ /dev/null @@ -1,26 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._key_vault_management_client import KeyVaultManagementClient -from ._version import VERSION - -__version__ = VERSION - -try: - from ._patch import __all__ as _patch_all - from ._patch import * # pylint: disable=unused-wildcard-import -except ImportError: - _patch_all = [] -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "KeyVaultManagementClient", -] -__all__.extend([p for p in _patch_all if p not in __all__]) - -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/_configuration.py deleted file mode 100644 index e48638f3dcb1..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/_configuration.py +++ /dev/null @@ -1,66 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from typing import Any, TYPE_CHECKING - -from azure.core.pipeline import policies -from azure.mgmt.core.policies import ARMChallengeAuthenticationPolicy, ARMHttpLoggingPolicy - -from ._version import VERSION - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials import TokenCredential - - -class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long - """Configuration for KeyVaultManagementClient. - - Note that all parameters used to create this instance are saved as instance - attributes. - - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials.TokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :keyword api_version: Api Version. Default value is "2022-07-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str - """ - - def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None: - api_version: str = kwargs.pop("api_version", "2022-07-01") - - if credential is None: - raise ValueError("Parameter 'credential' must not be None.") - if subscription_id is None: - raise ValueError("Parameter 'subscription_id' must not be None.") - - self.credential = credential - self.subscription_id = subscription_id - self.api_version = api_version - self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) - kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) - self.polling_interval = kwargs.get("polling_interval", 30) - self._configure(**kwargs) - - def _configure(self, **kwargs: Any) -> None: - 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.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**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) - self.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs) - self.authentication_policy = kwargs.get("authentication_policy") - if self.credential and not self.authentication_policy: - self.authentication_policy = ARMChallengeAuthenticationPolicy( - self.credential, *self.credential_scopes, **kwargs - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/_key_vault_management_client.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/_key_vault_management_client.py deleted file mode 100644 index eb2254db7524..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/_key_vault_management_client.py +++ /dev/null @@ -1,162 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from copy import deepcopy -from typing import Any, TYPE_CHECKING -from typing_extensions import Self - -from azure.core.pipeline import policies -from azure.core.rest import HttpRequest, HttpResponse -from azure.mgmt.core import ARMPipelineClient -from azure.mgmt.core.policies import ARMAutoResourceProviderRegistrationPolicy - -from . import models as _models -from .._serialization import Deserializer, Serializer -from ._configuration import KeyVaultManagementClientConfiguration -from .operations import ( - KeysOperations, - MHSMPrivateEndpointConnectionsOperations, - MHSMPrivateLinkResourcesOperations, - ManagedHsmsOperations, - Operations, - PrivateEndpointConnectionsOperations, - PrivateLinkResourcesOperations, - SecretsOperations, - VaultsOperations, -) - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials import TokenCredential - - -class KeyVaultManagementClient: # pylint: disable=client-accepts-api-version-keyword,too-many-instance-attributes - """The Azure management API provides a RESTful set of web services that interact with Azure Key - Vault. - - :ivar keys: KeysOperations operations - :vartype keys: azure.mgmt.keyvault.v2022_07_01.operations.KeysOperations - :ivar vaults: VaultsOperations operations - :vartype vaults: azure.mgmt.keyvault.v2022_07_01.operations.VaultsOperations - :ivar private_endpoint_connections: PrivateEndpointConnectionsOperations operations - :vartype private_endpoint_connections: - azure.mgmt.keyvault.v2022_07_01.operations.PrivateEndpointConnectionsOperations - :ivar private_link_resources: PrivateLinkResourcesOperations operations - :vartype private_link_resources: - azure.mgmt.keyvault.v2022_07_01.operations.PrivateLinkResourcesOperations - :ivar managed_hsms: ManagedHsmsOperations operations - :vartype managed_hsms: azure.mgmt.keyvault.v2022_07_01.operations.ManagedHsmsOperations - :ivar mhsm_private_endpoint_connections: MHSMPrivateEndpointConnectionsOperations operations - :vartype mhsm_private_endpoint_connections: - azure.mgmt.keyvault.v2022_07_01.operations.MHSMPrivateEndpointConnectionsOperations - :ivar mhsm_private_link_resources: MHSMPrivateLinkResourcesOperations operations - :vartype mhsm_private_link_resources: - azure.mgmt.keyvault.v2022_07_01.operations.MHSMPrivateLinkResourcesOperations - :ivar operations: Operations operations - :vartype operations: azure.mgmt.keyvault.v2022_07_01.operations.Operations - :ivar secrets: SecretsOperations operations - :vartype secrets: azure.mgmt.keyvault.v2022_07_01.operations.SecretsOperations - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials.TokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :param base_url: Service URL. Default value is "https://management.azure.com". - :type base_url: str - :keyword api_version: Api Version. Default value is "2022-07-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. - """ - - def __init__( - self, - credential: "TokenCredential", - subscription_id: str, - base_url: str = "https://management.azure.com", - **kwargs: Any - ) -> None: - self._config = KeyVaultManagementClientConfiguration( - credential=credential, subscription_id=subscription_id, **kwargs - ) - _policies = kwargs.pop("policies", None) - if _policies is None: - _policies = [ - policies.RequestIdPolicy(**kwargs), - self._config.headers_policy, - self._config.user_agent_policy, - self._config.proxy_policy, - policies.ContentDecodePolicy(**kwargs), - ARMAutoResourceProviderRegistrationPolicy(), - self._config.redirect_policy, - self._config.retry_policy, - self._config.authentication_policy, - self._config.custom_hook_policy, - self._config.logging_policy, - policies.DistributedTracingPolicy(**kwargs), - policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, - self._config.http_logging_policy, - ] - self._client: ARMPipelineClient = ARMPipelineClient(base_url=base_url, policies=_policies, **kwargs) - - client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} - self._serialize = Serializer(client_models) - self._deserialize = Deserializer(client_models) - self._serialize.client_side_validation = False - self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize, "2022-07-01") - self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize, "2022-07-01") - self.private_endpoint_connections = PrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2022-07-01" - ) - self.private_link_resources = PrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2022-07-01" - ) - self.managed_hsms = ManagedHsmsOperations( - self._client, self._config, self._serialize, self._deserialize, "2022-07-01" - ) - self.mhsm_private_endpoint_connections = MHSMPrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2022-07-01" - ) - self.mhsm_private_link_resources = MHSMPrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2022-07-01" - ) - self.operations = Operations(self._client, self._config, self._serialize, self._deserialize, "2022-07-01") - self.secrets = SecretsOperations(self._client, self._config, self._serialize, self._deserialize, "2022-07-01") - - def _send_request(self, request: HttpRequest, *, stream: bool = False, **kwargs: Any) -> HttpResponse: - """Runs the network request through the client's chained policies. - - >>> from azure.core.rest import HttpRequest - >>> request = HttpRequest("GET", "https://www.example.org/") - - >>> response = client._send_request(request) - - - For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request - - :param request: The network request you want to make. Required. - :type request: ~azure.core.rest.HttpRequest - :keyword bool stream: Whether the response payload will be streamed. Defaults to False. - :return: The response of your network call. Does not do error handling on your response. - :rtype: ~azure.core.rest.HttpResponse - """ - - request_copy = deepcopy(request) - request_copy.url = self._client.format_url(request_copy.url) - return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore - - def close(self) -> None: - self._client.close() - - def __enter__(self) -> Self: - self._client.__enter__() - return self - - def __exit__(self, *exc_details: Any) -> None: - self._client.__exit__(*exc_details) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/_metadata.json b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/_metadata.json deleted file mode 100644 index e843ca6d4a93..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/_metadata.json +++ /dev/null @@ -1,118 +0,0 @@ -{ - "chosen_version": "2022-07-01", - "total_api_version_list": ["2022-07-01"], - "client": { - "name": "KeyVaultManagementClient", - "filename": "_key_vault_management_client", - "description": "The Azure management API provides a RESTful set of web services that interact with Azure Key Vault.", - "host_value": "\"https://management.azure.com\"", - "parameterized_host_template": null, - "azure_arm": true, - "has_public_lro_operations": true, - "client_side_validation": false, - "sync_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"sdkcore\": {\"azure.mgmt.core\": [\"ARMPipelineClient\"], \"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"ARMAutoResourceProviderRegistrationPolicy\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \".._serialization\": [\"Deserializer\", \"Serializer\"]}, \"stdlib\": {\"typing_extensions\": [\"Self\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}}", - "async_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"sdkcore\": {\"azure.mgmt.core\": [\"AsyncARMPipelineClient\"], \"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"AsyncARMAutoResourceProviderRegistrationPolicy\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \"..._serialization\": [\"Deserializer\", \"Serializer\"]}, \"stdlib\": {\"typing_extensions\": [\"Self\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"]}}}" - }, - "global_parameters": { - "sync": { - "credential": { - "signature": "credential: \"TokenCredential\",", - "description": "Credential needed for the client to connect to Azure. Required.", - "docstring_type": "~azure.core.credentials.TokenCredential", - "required": true, - "method_location": "positional" - }, - "subscription_id": { - "signature": "subscription_id: str,", - "description": "Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. Required.", - "docstring_type": "str", - "required": true, - "method_location": "positional" - } - }, - "async": { - "credential": { - "signature": "credential: \"AsyncTokenCredential\",", - "description": "Credential needed for the client to connect to Azure. Required.", - "docstring_type": "~azure.core.credentials_async.AsyncTokenCredential", - "required": true - }, - "subscription_id": { - "signature": "subscription_id: str,", - "description": "Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. Required.", - "docstring_type": "str", - "required": true - } - }, - "constant": { - }, - "call": "credential, subscription_id", - "service_client_specific": { - "sync": { - "api_version": { - "signature": "api_version: Optional[str]=None,", - "description": "API version to use if no profile is provided, or if missing in profile.", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "base_url": { - "signature": "base_url: str = \"https://management.azure.com\",", - "description": "Service URL", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "profile": { - "signature": "profile: KnownProfiles=KnownProfiles.default,", - "description": "A profile definition, from KnownProfiles to dict.", - "docstring_type": "azure.profiles.KnownProfiles", - "required": false, - "method_location": "positional" - } - }, - "async": { - "api_version": { - "signature": "api_version: Optional[str] = None,", - "description": "API version to use if no profile is provided, or if missing in profile.", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "base_url": { - "signature": "base_url: str = \"https://management.azure.com\",", - "description": "Service URL", - "docstring_type": "str", - "required": false, - "method_location": "positional" - }, - "profile": { - "signature": "profile: KnownProfiles = KnownProfiles.default,", - "description": "A profile definition, from KnownProfiles to dict.", - "docstring_type": "azure.profiles.KnownProfiles", - "required": false, - "method_location": "positional" - } - } - } - }, - "config": { - "credential": true, - "credential_scopes": ["https://management.azure.com/.default"], - "credential_call_sync": "ARMChallengeAuthenticationPolicy(self.credential, *self.credential_scopes, **kwargs)", - "credential_call_async": "AsyncARMChallengeAuthenticationPolicy(self.credential, *self.credential_scopes, **kwargs)", - "sync_imports": "{\"regular\": {\"sdkcore\": {\"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"ARMChallengeAuthenticationPolicy\", \"ARMHttpLoggingPolicy\"]}, \"local\": {\"._version\": [\"VERSION\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}}", - "async_imports": "{\"regular\": {\"sdkcore\": {\"azure.core.pipeline\": [\"policies\"], \"azure.mgmt.core.policies\": [\"ARMHttpLoggingPolicy\", \"AsyncARMChallengeAuthenticationPolicy\"]}, \"local\": {\".._version\": [\"VERSION\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\"]}}, \"typing\": {\"sdkcore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"]}}}" - }, - "operation_groups": { - "keys": "KeysOperations", - "vaults": "VaultsOperations", - "private_endpoint_connections": "PrivateEndpointConnectionsOperations", - "private_link_resources": "PrivateLinkResourcesOperations", - "managed_hsms": "ManagedHsmsOperations", - "mhsm_private_endpoint_connections": "MHSMPrivateEndpointConnectionsOperations", - "mhsm_private_link_resources": "MHSMPrivateLinkResourcesOperations", - "operations": "Operations", - "secrets": "SecretsOperations" - } -} diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/_version.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/_version.py deleted file mode 100644 index 3b99a1418535..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/_version.py +++ /dev/null @@ -1,9 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -VERSION = "10.3.1" diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/__init__.py deleted file mode 100644 index 6ba0c5a05353..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/__init__.py +++ /dev/null @@ -1,23 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._key_vault_management_client import KeyVaultManagementClient - -try: - from ._patch import __all__ as _patch_all - from ._patch import * # pylint: disable=unused-wildcard-import -except ImportError: - _patch_all = [] -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "KeyVaultManagementClient", -] -__all__.extend([p for p in _patch_all if p not in __all__]) - -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/_configuration.py deleted file mode 100644 index 8d5da4f2c90f..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/_configuration.py +++ /dev/null @@ -1,66 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from typing import Any, TYPE_CHECKING - -from azure.core.pipeline import policies -from azure.mgmt.core.policies import ARMHttpLoggingPolicy, AsyncARMChallengeAuthenticationPolicy - -from .._version import VERSION - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials_async import AsyncTokenCredential - - -class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long - """Configuration for KeyVaultManagementClient. - - Note that all parameters used to create this instance are saved as instance - attributes. - - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials_async.AsyncTokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :keyword api_version: Api Version. Default value is "2022-07-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str - """ - - def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None: - api_version: str = kwargs.pop("api_version", "2022-07-01") - - if credential is None: - raise ValueError("Parameter 'credential' must not be None.") - if subscription_id is None: - raise ValueError("Parameter 'subscription_id' must not be None.") - - self.credential = credential - self.subscription_id = subscription_id - self.api_version = api_version - self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) - kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) - self.polling_interval = kwargs.get("polling_interval", 30) - self._configure(**kwargs) - - def _configure(self, **kwargs: Any) -> None: - 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.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**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) - self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) - self.authentication_policy = kwargs.get("authentication_policy") - if self.credential and not self.authentication_policy: - self.authentication_policy = AsyncARMChallengeAuthenticationPolicy( - self.credential, *self.credential_scopes, **kwargs - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/_key_vault_management_client.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/_key_vault_management_client.py deleted file mode 100644 index 7bf15edee181..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/_key_vault_management_client.py +++ /dev/null @@ -1,164 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from copy import deepcopy -from typing import Any, Awaitable, TYPE_CHECKING -from typing_extensions import Self - -from azure.core.pipeline import policies -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.mgmt.core import AsyncARMPipelineClient -from azure.mgmt.core.policies import AsyncARMAutoResourceProviderRegistrationPolicy - -from .. import models as _models -from ..._serialization import Deserializer, Serializer -from ._configuration import KeyVaultManagementClientConfiguration -from .operations import ( - KeysOperations, - MHSMPrivateEndpointConnectionsOperations, - MHSMPrivateLinkResourcesOperations, - ManagedHsmsOperations, - Operations, - PrivateEndpointConnectionsOperations, - PrivateLinkResourcesOperations, - SecretsOperations, - VaultsOperations, -) - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials_async import AsyncTokenCredential - - -class KeyVaultManagementClient: # pylint: disable=client-accepts-api-version-keyword,too-many-instance-attributes - """The Azure management API provides a RESTful set of web services that interact with Azure Key - Vault. - - :ivar keys: KeysOperations operations - :vartype keys: azure.mgmt.keyvault.v2022_07_01.aio.operations.KeysOperations - :ivar vaults: VaultsOperations operations - :vartype vaults: azure.mgmt.keyvault.v2022_07_01.aio.operations.VaultsOperations - :ivar private_endpoint_connections: PrivateEndpointConnectionsOperations operations - :vartype private_endpoint_connections: - azure.mgmt.keyvault.v2022_07_01.aio.operations.PrivateEndpointConnectionsOperations - :ivar private_link_resources: PrivateLinkResourcesOperations operations - :vartype private_link_resources: - azure.mgmt.keyvault.v2022_07_01.aio.operations.PrivateLinkResourcesOperations - :ivar managed_hsms: ManagedHsmsOperations operations - :vartype managed_hsms: azure.mgmt.keyvault.v2022_07_01.aio.operations.ManagedHsmsOperations - :ivar mhsm_private_endpoint_connections: MHSMPrivateEndpointConnectionsOperations operations - :vartype mhsm_private_endpoint_connections: - azure.mgmt.keyvault.v2022_07_01.aio.operations.MHSMPrivateEndpointConnectionsOperations - :ivar mhsm_private_link_resources: MHSMPrivateLinkResourcesOperations operations - :vartype mhsm_private_link_resources: - azure.mgmt.keyvault.v2022_07_01.aio.operations.MHSMPrivateLinkResourcesOperations - :ivar operations: Operations operations - :vartype operations: azure.mgmt.keyvault.v2022_07_01.aio.operations.Operations - :ivar secrets: SecretsOperations operations - :vartype secrets: azure.mgmt.keyvault.v2022_07_01.aio.operations.SecretsOperations - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials_async.AsyncTokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :param base_url: Service URL. Default value is "https://management.azure.com". - :type base_url: str - :keyword api_version: Api Version. Default value is "2022-07-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. - """ - - def __init__( - self, - credential: "AsyncTokenCredential", - subscription_id: str, - base_url: str = "https://management.azure.com", - **kwargs: Any - ) -> None: - self._config = KeyVaultManagementClientConfiguration( - credential=credential, subscription_id=subscription_id, **kwargs - ) - _policies = kwargs.pop("policies", None) - if _policies is None: - _policies = [ - policies.RequestIdPolicy(**kwargs), - self._config.headers_policy, - self._config.user_agent_policy, - self._config.proxy_policy, - policies.ContentDecodePolicy(**kwargs), - AsyncARMAutoResourceProviderRegistrationPolicy(), - self._config.redirect_policy, - self._config.retry_policy, - self._config.authentication_policy, - self._config.custom_hook_policy, - self._config.logging_policy, - policies.DistributedTracingPolicy(**kwargs), - policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, - self._config.http_logging_policy, - ] - self._client: AsyncARMPipelineClient = AsyncARMPipelineClient(base_url=base_url, policies=_policies, **kwargs) - - client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} - self._serialize = Serializer(client_models) - self._deserialize = Deserializer(client_models) - self._serialize.client_side_validation = False - self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize, "2022-07-01") - self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize, "2022-07-01") - self.private_endpoint_connections = PrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2022-07-01" - ) - self.private_link_resources = PrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2022-07-01" - ) - self.managed_hsms = ManagedHsmsOperations( - self._client, self._config, self._serialize, self._deserialize, "2022-07-01" - ) - self.mhsm_private_endpoint_connections = MHSMPrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2022-07-01" - ) - self.mhsm_private_link_resources = MHSMPrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2022-07-01" - ) - self.operations = Operations(self._client, self._config, self._serialize, self._deserialize, "2022-07-01") - self.secrets = SecretsOperations(self._client, self._config, self._serialize, self._deserialize, "2022-07-01") - - def _send_request( - self, request: HttpRequest, *, stream: bool = False, **kwargs: Any - ) -> Awaitable[AsyncHttpResponse]: - """Runs the network request through the client's chained policies. - - >>> from azure.core.rest import HttpRequest - >>> request = HttpRequest("GET", "https://www.example.org/") - - >>> response = await client._send_request(request) - - - For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request - - :param request: The network request you want to make. Required. - :type request: ~azure.core.rest.HttpRequest - :keyword bool stream: Whether the response payload will be streamed. Defaults to False. - :return: The response of your network call. Does not do error handling on your response. - :rtype: ~azure.core.rest.AsyncHttpResponse - """ - - request_copy = deepcopy(request) - request_copy.url = self._client.format_url(request_copy.url) - return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore - - async def close(self) -> None: - await self._client.close() - - async def __aenter__(self) -> Self: - await self._client.__aenter__() - return self - - async def __aexit__(self, *exc_details: Any) -> None: - await self._client.__aexit__(*exc_details) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/__init__.py deleted file mode 100644 index 224be3f73e55..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/__init__.py +++ /dev/null @@ -1,35 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._keys_operations import KeysOperations -from ._vaults_operations import VaultsOperations -from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations -from ._private_link_resources_operations import PrivateLinkResourcesOperations -from ._managed_hsms_operations import ManagedHsmsOperations -from ._mhsm_private_endpoint_connections_operations import MHSMPrivateEndpointConnectionsOperations -from ._mhsm_private_link_resources_operations import MHSMPrivateLinkResourcesOperations -from ._operations import Operations -from ._secrets_operations import SecretsOperations - -from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "KeysOperations", - "VaultsOperations", - "PrivateEndpointConnectionsOperations", - "PrivateLinkResourcesOperations", - "ManagedHsmsOperations", - "MHSMPrivateEndpointConnectionsOperations", - "MHSMPrivateLinkResourcesOperations", - "Operations", - "SecretsOperations", -] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_mhsm_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_mhsm_private_endpoint_connections_operations.py deleted file mode 100644 index 742711d02002..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_mhsm_private_endpoint_connections_operations.py +++ /dev/null @@ -1,487 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._mhsm_private_endpoint_connections_operations import ( - build_delete_request, - build_get_request, - build_list_by_resource_request, - build_put_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class MHSMPrivateEndpointConnectionsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2022_07_01.aio.KeyVaultManagementClient`'s - :attr:`mhsm_private_endpoint_connections` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list_by_resource( - self, resource_group_name: str, name: str, **kwargs: Any - ) -> AsyncIterable["_models.MHSMPrivateEndpointConnection"]: - """The List operation gets information about the private endpoint connections associated with the - managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :return: An iterator like instance of either MHSMPrivateEndpointConnection or the result of - cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("MHSMPrivateEndpointConnectionsListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace_async - async def get( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Gets the specified private endpoint connection associated with the managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: _models.MHSMPrivateEndpointConnection, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: Union[_models.MHSMPrivateEndpointConnection, IO[bytes]], - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Is either a - MHSMPrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection or - IO[bytes] - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _json = self._serialize.body(properties, "MHSMPrivateEndpointConnection") - - _request = build_put_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Azure-AsyncOperation"] = self._deserialize( - "str", response.headers.get("Azure-AsyncOperation") - ) - - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - async def _delete_initial( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_delete( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> AsyncLROPoller[_models.MHSMPrivateEndpointConnection]: - """Deletes the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :return: An instance of AsyncLROPoller that returns either MHSMPrivateEndpointConnection or the - result of cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._delete_initial( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.MHSMPrivateEndpointConnection].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.MHSMPrivateEndpointConnection]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_mhsm_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_mhsm_private_link_resources_operations.py deleted file mode 100644 index a41899a61155..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_mhsm_private_link_resources_operations.py +++ /dev/null @@ -1,112 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._mhsm_private_link_resources_operations import build_list_by_mhsm_resource_request - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class MHSMPrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2022_07_01.aio.KeyVaultManagementClient`'s - :attr:`mhsm_private_link_resources` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace_async - async def list_by_mhsm_resource( - self, resource_group_name: str, name: str, **kwargs: Any - ) -> _models.MHSMPrivateLinkResourceListResult: - """Gets the private link resources supported for the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :return: MHSMPrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateLinkResourceListResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.MHSMPrivateLinkResourceListResult] = kwargs.pop("cls", None) - - _request = build_list_by_mhsm_resource_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("MHSMPrivateLinkResourceListResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_operations.py deleted file mode 100644 index e6c90bd9da0d..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_operations.py +++ /dev/null @@ -1,131 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, AsyncIterable, Callable, Dict, Optional, Type, TypeVar -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._operations import build_list_request - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class Operations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2022_07_01.aio.KeyVaultManagementClient`'s - :attr:`operations` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: - """Lists all of the available Key Vault Rest API operations. - - :return: An iterator like instance of either Operation or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.Operation] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("OperationListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_patch.py deleted file mode 100644 index 9b4f32f151b7..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_patch.py +++ /dev/null @@ -1,136 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -import sys -from typing import AsyncIterable, Any, Optional, List, Type -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ._vaults_operations import VaultsOperations as _VaultsOperations, ClsType -from ...operations._vaults_operations import build_list_request - -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports - -class VaultsOperations(_VaultsOperations): - - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - -__all__: List[str] = ["VaultsOperations"] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_private_endpoint_connections_operations.py deleted file mode 100644 index 7bc332a7d5fc..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_private_endpoint_connections_operations.py +++ /dev/null @@ -1,482 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._private_endpoint_connections_operations import ( - build_delete_request, - build_get_request, - build_list_by_resource_request, - build_put_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class PrivateEndpointConnectionsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2022_07_01.aio.KeyVaultManagementClient`'s - :attr:`private_endpoint_connections` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace_async - async def get( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Optional[_models.PrivateEndpointConnection]: - """Gets the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: PrivateEndpointConnection or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection or None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[Optional[_models.PrivateEndpointConnection]] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: _models.PrivateEndpointConnection, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: Union[_models.PrivateEndpointConnection, IO[bytes]], - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Is either a - PrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection or - IO[bytes] - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _json = self._serialize.body(properties, "PrivateEndpointConnection") - - _request = build_put_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Azure-AsyncOperation"] = self._deserialize( - "str", response.headers.get("Azure-AsyncOperation") - ) - - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - async def _delete_initial( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_delete( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> AsyncLROPoller[_models.PrivateEndpointConnection]: - """Deletes the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: An instance of AsyncLROPoller that returns either PrivateEndpointConnection or the - result of cls(response) - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._delete_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.PrivateEndpointConnection].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.PrivateEndpointConnection]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @distributed_trace - def list_by_resource( - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> AsyncIterable["_models.PrivateEndpointConnection"]: - """The List operation gets information about the private endpoint connections associated with the - vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :return: An iterator like instance of either PrivateEndpointConnection or the result of - cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.PrivateEndpointConnectionListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("PrivateEndpointConnectionListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_private_link_resources_operations.py deleted file mode 100644 index 5772d49d71a3..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_private_link_resources_operations.py +++ /dev/null @@ -1,111 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._private_link_resources_operations import build_list_by_vault_request - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class PrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2022_07_01.aio.KeyVaultManagementClient`'s - :attr:`private_link_resources` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace_async - async def list_by_vault( - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> _models.PrivateLinkResourceListResult: - """Gets the private link resources supported for the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :return: PrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateLinkResourceListResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.PrivateLinkResourceListResult] = kwargs.pop("cls", None) - - _request = build_list_by_vault_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_secrets_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_secrets_operations.py deleted file mode 100644 index f78d5ab1520b..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_secrets_operations.py +++ /dev/null @@ -1,518 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, Type, TypeVar, Union, overload -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._secrets_operations import ( - build_create_or_update_request, - build_get_request, - build_list_request, - build_update_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class SecretsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2022_07_01.aio.KeyVaultManagementClient`'s - :attr:`secrets` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @overload - async def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: _models.SecretCreateOrUpdateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. The value you provide may be copied globally for the - purpose of running the service. The value provided should not include personally identifiable - or sensitive information. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.SecretCreateOrUpdateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. The value you provide may be copied globally for the - purpose of running the service. The value provided should not include personally identifiable - or sensitive information. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: Union[_models.SecretCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. The value you provide may be copied globally for the - purpose of running the service. The value provided should not include personally identifiable - or sensitive information. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Is either a - SecretCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.SecretCreateOrUpdateParameters or - IO[bytes] - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "SecretCreateOrUpdateParameters") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: _models.SecretPatchParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.SecretPatchParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: Union[_models.SecretPatchParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Is either a SecretPatchParameters type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.SecretPatchParameters or IO[bytes] - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "SecretPatchParameters") - - _request = build_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def get(self, resource_group_name: str, vault_name: str, secret_name: str, **kwargs: Any) -> _models.Secret: - """Gets the specified secret. NOTE: This API is intended for internal use in ARM deployments. - Users should use the data-plane REST service for interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param secret_name: The name of the secret. Required. - :type secret_name: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list( - self, resource_group_name: str, vault_name: str, top: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable["_models.Secret"]: - """The List operation gets information about the secrets in a vault. NOTE: This API is intended - for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Secret or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.Secret] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.SecretListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("SecretListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_vaults_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_vaults_operations.py deleted file mode 100644 index 494551048ce5..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_vaults_operations.py +++ /dev/null @@ -1,1244 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import ( - Any, - AsyncIterable, - AsyncIterator, - Callable, - Dict, - IO, - Literal, - Optional, - Type, - TypeVar, - Union, - cast, - overload, -) -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._vaults_operations import ( - build_check_name_availability_request, - build_create_or_update_request, - build_delete_request, - build_get_deleted_request, - build_get_request, - build_list_by_resource_group_request, - build_list_by_subscription_request, - build_list_deleted_request, - build_list_request, - build_purge_deleted_request, - build_update_access_policy_request, - build_update_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class VaultsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2022_07_01.aio.KeyVaultManagementClient`'s - :attr:`vaults` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - async def _create_or_update_initial( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 201: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.VaultCreateOrUpdateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2022_07_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2022_07_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> AsyncLROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Is either a - VaultCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.VaultCreateOrUpdateParameters or - IO[bytes] - :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2022_07_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._create_or_update_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("Vault", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.Vault].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.Vault]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @overload - async def update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultPatchParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.VaultPatchParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultPatchParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Is either a VaultPatchParameters type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.VaultPatchParameters or IO[bytes] - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultPatchParameters") - - _request = build_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def delete( # pylint: disable=inconsistent-return-statements - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> None: - """Deletes the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault to delete. Required. - :type vault_name: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - @distributed_trace_async - async def get(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> _models.Vault: - """Gets the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: _models.VaultAccessPolicyParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2022_07_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.VaultAccessPolicyParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2022_07_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: Union[_models.VaultAccessPolicyParameters, IO[bytes]], - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2022_07_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Is either a - VaultAccessPolicyParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.VaultAccessPolicyParameters or - IO[bytes] - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.VaultAccessPolicyParameters] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") - - _request = build_update_access_policy_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - operation_kind=operation_kind, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription and - within the specified resource group. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedVault"]: - """Gets information about the deleted vaults in a subscription. - - :return: An iterator like instance of either DeletedVault or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.DeletedVault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.DeletedVaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("DeletedVaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace_async - async def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _models.DeletedVault: - """Gets the deleted Azure key vault. - - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param location: The location of the deleted vault. Required. - :type location: str - :return: DeletedVault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.DeletedVault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.DeletedVault] = kwargs.pop("cls", None) - - _request = build_get_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("DeletedVault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - async def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_purge_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_purge_deleted(self, vault_name: str, location: str, **kwargs: Any) -> AsyncLROPoller[None]: - """Permanently deletes the specified vault. aka Purges the deleted Azure key vault. - - :param vault_name: The name of the soft-deleted vault. Required. - :type vault_name: str - :param location: The location of the soft-deleted vault. Required. - :type location: str - :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._purge_deleted_initial( - vault_name=vault_name, - location=location, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @overload - async def check_name_availability( - self, - vault_name: _models.VaultCheckNameAvailabilityParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: ~azure.mgmt.keyvault.v2022_07_01.models.VaultCheckNameAvailabilityParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def check_name_availability( - self, vault_name: IO[bytes], *, content_type: str = "application/json", **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def check_name_availability( - self, vault_name: Union[_models.VaultCheckNameAvailabilityParameters, IO[bytes]], **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Is either a VaultCheckNameAvailabilityParameters type - or a IO[bytes] type. Required. - :type vault_name: ~azure.mgmt.keyvault.v2022_07_01.models.VaultCheckNameAvailabilityParameters - or IO[bytes] - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.CheckNameAvailabilityResult] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(vault_name, (IOBase, bytes)): - _content = vault_name - else: - _json = self._serialize.body(vault_name, "VaultCheckNameAvailabilityParameters") - - _request = build_check_name_availability_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/models/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/models/__init__.py deleted file mode 100644 index a84a0c24d4db..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/models/__init__.py +++ /dev/null @@ -1,227 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._models_py3 import AccessPolicyEntry -from ._models_py3 import Action -from ._models_py3 import Attributes -from ._models_py3 import CheckMhsmNameAvailabilityParameters -from ._models_py3 import CheckMhsmNameAvailabilityResult -from ._models_py3 import CheckNameAvailabilityResult -from ._models_py3 import CloudErrorBody -from ._models_py3 import DeletedManagedHsm -from ._models_py3 import DeletedManagedHsmListResult -from ._models_py3 import DeletedManagedHsmProperties -from ._models_py3 import DeletedVault -from ._models_py3 import DeletedVaultListResult -from ._models_py3 import DeletedVaultProperties -from ._models_py3 import DimensionProperties -from ._models_py3 import Error -from ._models_py3 import IPRule -from ._models_py3 import Key -from ._models_py3 import KeyAttributes -from ._models_py3 import KeyCreateParameters -from ._models_py3 import KeyListResult -from ._models_py3 import KeyProperties -from ._models_py3 import KeyReleasePolicy -from ._models_py3 import KeyRotationPolicyAttributes -from ._models_py3 import LifetimeAction -from ._models_py3 import LogSpecification -from ._models_py3 import MHSMIPRule -from ._models_py3 import MHSMNetworkRuleSet -from ._models_py3 import MHSMPrivateEndpoint -from ._models_py3 import MHSMPrivateEndpointConnection -from ._models_py3 import MHSMPrivateEndpointConnectionItem -from ._models_py3 import MHSMPrivateEndpointConnectionsListResult -from ._models_py3 import MHSMPrivateLinkResource -from ._models_py3 import MHSMPrivateLinkResourceListResult -from ._models_py3 import MHSMPrivateLinkServiceConnectionState -from ._models_py3 import MHSMVirtualNetworkRule -from ._models_py3 import ManagedHSMSecurityDomainProperties -from ._models_py3 import ManagedHsm -from ._models_py3 import ManagedHsmError -from ._models_py3 import ManagedHsmListResult -from ._models_py3 import ManagedHsmProperties -from ._models_py3 import ManagedHsmResource -from ._models_py3 import ManagedHsmSku -from ._models_py3 import MetricSpecification -from ._models_py3 import NetworkRuleSet -from ._models_py3 import Operation -from ._models_py3 import OperationDisplay -from ._models_py3 import OperationListResult -from ._models_py3 import Permissions -from ._models_py3 import PrivateEndpoint -from ._models_py3 import PrivateEndpointConnection -from ._models_py3 import PrivateEndpointConnectionItem -from ._models_py3 import PrivateEndpointConnectionListResult -from ._models_py3 import PrivateLinkResource -from ._models_py3 import PrivateLinkResourceListResult -from ._models_py3 import PrivateLinkServiceConnectionState -from ._models_py3 import Resource -from ._models_py3 import ResourceListResult -from ._models_py3 import RotationPolicy -from ._models_py3 import Secret -from ._models_py3 import SecretAttributes -from ._models_py3 import SecretCreateOrUpdateParameters -from ._models_py3 import SecretListResult -from ._models_py3 import SecretPatchParameters -from ._models_py3 import SecretPatchProperties -from ._models_py3 import SecretProperties -from ._models_py3 import ServiceSpecification -from ._models_py3 import Sku -from ._models_py3 import SystemData -from ._models_py3 import Trigger -from ._models_py3 import Vault -from ._models_py3 import VaultAccessPolicyParameters -from ._models_py3 import VaultAccessPolicyProperties -from ._models_py3 import VaultCheckNameAvailabilityParameters -from ._models_py3 import VaultCreateOrUpdateParameters -from ._models_py3 import VaultListResult -from ._models_py3 import VaultPatchParameters -from ._models_py3 import VaultPatchProperties -from ._models_py3 import VaultProperties -from ._models_py3 import VirtualNetworkRule - -from ._key_vault_management_client_enums import AccessPolicyUpdateKind -from ._key_vault_management_client_enums import ActionsRequired -from ._key_vault_management_client_enums import ActivationStatus -from ._key_vault_management_client_enums import CertificatePermissions -from ._key_vault_management_client_enums import CreateMode -from ._key_vault_management_client_enums import DeletionRecoveryLevel -from ._key_vault_management_client_enums import IdentityType -from ._key_vault_management_client_enums import JsonWebKeyCurveName -from ._key_vault_management_client_enums import JsonWebKeyOperation -from ._key_vault_management_client_enums import JsonWebKeyType -from ._key_vault_management_client_enums import KeyPermissions -from ._key_vault_management_client_enums import KeyRotationPolicyActionType -from ._key_vault_management_client_enums import ManagedHsmSkuFamily -from ._key_vault_management_client_enums import ManagedHsmSkuName -from ._key_vault_management_client_enums import NetworkRuleAction -from ._key_vault_management_client_enums import NetworkRuleBypassOptions -from ._key_vault_management_client_enums import PrivateEndpointConnectionProvisioningState -from ._key_vault_management_client_enums import PrivateEndpointServiceConnectionStatus -from ._key_vault_management_client_enums import ProvisioningState -from ._key_vault_management_client_enums import PublicNetworkAccess -from ._key_vault_management_client_enums import Reason -from ._key_vault_management_client_enums import SecretPermissions -from ._key_vault_management_client_enums import SkuFamily -from ._key_vault_management_client_enums import SkuName -from ._key_vault_management_client_enums import StoragePermissions -from ._key_vault_management_client_enums import VaultProvisioningState -from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "AccessPolicyEntry", - "Action", - "Attributes", - "CheckMhsmNameAvailabilityParameters", - "CheckMhsmNameAvailabilityResult", - "CheckNameAvailabilityResult", - "CloudErrorBody", - "DeletedManagedHsm", - "DeletedManagedHsmListResult", - "DeletedManagedHsmProperties", - "DeletedVault", - "DeletedVaultListResult", - "DeletedVaultProperties", - "DimensionProperties", - "Error", - "IPRule", - "Key", - "KeyAttributes", - "KeyCreateParameters", - "KeyListResult", - "KeyProperties", - "KeyReleasePolicy", - "KeyRotationPolicyAttributes", - "LifetimeAction", - "LogSpecification", - "MHSMIPRule", - "MHSMNetworkRuleSet", - "MHSMPrivateEndpoint", - "MHSMPrivateEndpointConnection", - "MHSMPrivateEndpointConnectionItem", - "MHSMPrivateEndpointConnectionsListResult", - "MHSMPrivateLinkResource", - "MHSMPrivateLinkResourceListResult", - "MHSMPrivateLinkServiceConnectionState", - "MHSMVirtualNetworkRule", - "ManagedHSMSecurityDomainProperties", - "ManagedHsm", - "ManagedHsmError", - "ManagedHsmListResult", - "ManagedHsmProperties", - "ManagedHsmResource", - "ManagedHsmSku", - "MetricSpecification", - "NetworkRuleSet", - "Operation", - "OperationDisplay", - "OperationListResult", - "Permissions", - "PrivateEndpoint", - "PrivateEndpointConnection", - "PrivateEndpointConnectionItem", - "PrivateEndpointConnectionListResult", - "PrivateLinkResource", - "PrivateLinkResourceListResult", - "PrivateLinkServiceConnectionState", - "Resource", - "ResourceListResult", - "RotationPolicy", - "Secret", - "SecretAttributes", - "SecretCreateOrUpdateParameters", - "SecretListResult", - "SecretPatchParameters", - "SecretPatchProperties", - "SecretProperties", - "ServiceSpecification", - "Sku", - "SystemData", - "Trigger", - "Vault", - "VaultAccessPolicyParameters", - "VaultAccessPolicyProperties", - "VaultCheckNameAvailabilityParameters", - "VaultCreateOrUpdateParameters", - "VaultListResult", - "VaultPatchParameters", - "VaultPatchProperties", - "VaultProperties", - "VirtualNetworkRule", - "AccessPolicyUpdateKind", - "ActionsRequired", - "ActivationStatus", - "CertificatePermissions", - "CreateMode", - "DeletionRecoveryLevel", - "IdentityType", - "JsonWebKeyCurveName", - "JsonWebKeyOperation", - "JsonWebKeyType", - "KeyPermissions", - "KeyRotationPolicyActionType", - "ManagedHsmSkuFamily", - "ManagedHsmSkuName", - "NetworkRuleAction", - "NetworkRuleBypassOptions", - "PrivateEndpointConnectionProvisioningState", - "PrivateEndpointServiceConnectionStatus", - "ProvisioningState", - "PublicNetworkAccess", - "Reason", - "SecretPermissions", - "SkuFamily", - "SkuName", - "StoragePermissions", - "VaultProvisioningState", -] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/models/_key_vault_management_client_enums.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/models/_key_vault_management_client_enums.py deleted file mode 100644 index 9eec88d58ead..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/models/_key_vault_management_client_enums.py +++ /dev/null @@ -1,301 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from enum import Enum -from azure.core import CaseInsensitiveEnumMeta - - -class AccessPolicyUpdateKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """AccessPolicyUpdateKind.""" - - ADD = "add" - REPLACE = "replace" - REMOVE = "remove" - - -class ActionsRequired(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """A message indicating if changes on the service provider require any updates on the consumer.""" - - NONE = "None" - - -class ActivationStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Activation Status.""" - - ACTIVE = "Active" - """The managed HSM Pool is active.""" - NOT_ACTIVATED = "NotActivated" - """The managed HSM Pool is not yet activated.""" - UNKNOWN = "Unknown" - """An unknown error occurred while activating managed hsm.""" - FAILED = "Failed" - """Failed to activate managed hsm.""" - - -class CertificatePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """CertificatePermissions.""" - - ALL = "all" - GET = "get" - LIST = "list" - DELETE = "delete" - CREATE = "create" - IMPORT = "import" - UPDATE = "update" - MANAGECONTACTS = "managecontacts" - GETISSUERS = "getissuers" - LISTISSUERS = "listissuers" - SETISSUERS = "setissuers" - DELETEISSUERS = "deleteissuers" - MANAGEISSUERS = "manageissuers" - RECOVER = "recover" - PURGE = "purge" - BACKUP = "backup" - RESTORE = "restore" - IMPORT_ENUM = "import" - - -class CreateMode(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The vault's create mode to indicate whether the vault need to be recovered or not.""" - - RECOVER = "recover" - DEFAULT = "default" - - -class DeletionRecoveryLevel(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The deletion recovery level currently in effect for the object. If it contains 'Purgeable', - then the object can be permanently deleted by a privileged user; otherwise, only the system can - purge the object at the end of the retention interval. - """ - - PURGEABLE = "Purgeable" - RECOVERABLE_PURGEABLE = "Recoverable+Purgeable" - RECOVERABLE = "Recoverable" - RECOVERABLE_PROTECTED_SUBSCRIPTION = "Recoverable+ProtectedSubscription" - - -class IdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of identity.""" - - USER = "User" - APPLICATION = "Application" - MANAGED_IDENTITY = "ManagedIdentity" - KEY = "Key" - - -class JsonWebKeyCurveName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The elliptic curve name. For valid values, see JsonWebKeyCurveName.""" - - P256 = "P-256" - P384 = "P-384" - P521 = "P-521" - P256_K = "P-256K" - - -class JsonWebKeyOperation(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The permitted JSON web key operations of the key. For more information, see - JsonWebKeyOperation. - """ - - ENCRYPT = "encrypt" - DECRYPT = "decrypt" - SIGN = "sign" - VERIFY = "verify" - WRAP_KEY = "wrapKey" - UNWRAP_KEY = "unwrapKey" - IMPORT = "import" - RELEASE = "release" - IMPORT_ENUM = "import" - - -class JsonWebKeyType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of the key. For valid values, see JsonWebKeyType.""" - - EC = "EC" - EC_HSM = "EC-HSM" - RSA = "RSA" - RSA_HSM = "RSA-HSM" - - -class KeyPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """KeyPermissions.""" - - ALL = "all" - ENCRYPT = "encrypt" - DECRYPT = "decrypt" - WRAP_KEY = "wrapKey" - UNWRAP_KEY = "unwrapKey" - SIGN = "sign" - VERIFY = "verify" - GET = "get" - LIST = "list" - CREATE = "create" - UPDATE = "update" - IMPORT = "import" - DELETE = "delete" - BACKUP = "backup" - RESTORE = "restore" - RECOVER = "recover" - PURGE = "purge" - RELEASE = "release" - ROTATE = "rotate" - GETROTATIONPOLICY = "getrotationpolicy" - SETROTATIONPOLICY = "setrotationpolicy" - IMPORT_ENUM = "import" - - -class KeyRotationPolicyActionType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of the action. The value should be compared case-insensitively.""" - - ROTATE = "Rotate" - """Rotate the key based on the key policy.""" - NOTIFY = "Notify" - """Trigger Event Grid events. Defaults to 30 days before expiry. Key Vault only.""" - - -class ManagedHsmSkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU Family of the managed HSM Pool.""" - - B = "B" - - -class ManagedHsmSkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU of the managed HSM Pool.""" - - STANDARD_B1 = "Standard_B1" - CUSTOM_B32 = "Custom_B32" - CUSTOM_B6 = "Custom_B6" - - -class NetworkRuleAction(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The default action when no rule from ipRules and from virtualNetworkRules match. This is only - used after the bypass property has been evaluated. - """ - - ALLOW = "Allow" - DENY = "Deny" - - -class NetworkRuleBypassOptions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Tells what traffic can bypass network rules. This can be 'AzureServices' or 'None'. If not - specified the default is 'AzureServices'. - """ - - AZURE_SERVICES = "AzureServices" - NONE = "None" - - -class PrivateEndpointConnectionProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The current provisioning state.""" - - SUCCEEDED = "Succeeded" - CREATING = "Creating" - UPDATING = "Updating" - DELETING = "Deleting" - FAILED = "Failed" - DISCONNECTED = "Disconnected" - - -class PrivateEndpointServiceConnectionStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The private endpoint connection status.""" - - PENDING = "Pending" - APPROVED = "Approved" - REJECTED = "Rejected" - DISCONNECTED = "Disconnected" - - -class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Provisioning state.""" - - SUCCEEDED = "Succeeded" - """The managed HSM Pool has been full provisioned.""" - PROVISIONING = "Provisioning" - """The managed HSM Pool is currently being provisioned.""" - FAILED = "Failed" - """Provisioning of the managed HSM Pool has failed.""" - UPDATING = "Updating" - """The managed HSM Pool is currently being updated.""" - DELETING = "Deleting" - """The managed HSM Pool is currently being deleted.""" - ACTIVATED = "Activated" - """The managed HSM pool is ready for normal use.""" - SECURITY_DOMAIN_RESTORE = "SecurityDomainRestore" - """The managed HSM pool is waiting for a security domain restore action.""" - RESTORING = "Restoring" - """The managed HSM pool is being restored from full HSM backup.""" - - -class PublicNetworkAccess(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Control permission to the managed HSM from public networks.""" - - ENABLED = "Enabled" - DISABLED = "Disabled" - - -class Reason(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The reason that a vault name could not be used. The Reason element is only returned if - NameAvailable is false. - """ - - ACCOUNT_NAME_INVALID = "AccountNameInvalid" - ALREADY_EXISTS = "AlreadyExists" - - -class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SecretPermissions.""" - - ALL = "all" - GET = "get" - LIST = "list" - SET = "set" - DELETE = "delete" - BACKUP = "backup" - RESTORE = "restore" - RECOVER = "recover" - PURGE = "purge" - - -class SkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU family name.""" - - A = "A" - - -class SkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU name to specify whether the key vault is a standard vault or a premium vault.""" - - STANDARD = "standard" - PREMIUM = "premium" - - -class StoragePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """StoragePermissions.""" - - ALL = "all" - GET = "get" - LIST = "list" - DELETE = "delete" - SET = "set" - UPDATE = "update" - REGENERATEKEY = "regeneratekey" - RECOVER = "recover" - PURGE = "purge" - BACKUP = "backup" - RESTORE = "restore" - SETSAS = "setsas" - LISTSAS = "listsas" - GETSAS = "getsas" - DELETESAS = "deletesas" - - -class VaultProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Provisioning state of the vault.""" - - SUCCEEDED = "Succeeded" - REGISTERING_DNS = "RegisteringDns" diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/models/_models_py3.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/models/_models_py3.py deleted file mode 100644 index 3a1d0fd50dd1..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/models/_models_py3.py +++ /dev/null @@ -1,3795 +0,0 @@ -# coding=utf-8 -# pylint: disable=too-many-lines -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -import datetime -from typing import Any, Dict, List, Optional, TYPE_CHECKING, Union - -from ... import _serialization - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from .. import models as _models - - -class AccessPolicyEntry(_serialization.Model): - """An identity that have access to the key vault. All identities in the array must use the same - tenant ID as the key vault's tenant ID. - - All required parameters must be populated in order to send to server. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :vartype tenant_id: str - :ivar object_id: The object ID of a user, service principal or security group in the Azure - Active Directory tenant for the vault. The object ID must be unique for the list of access - policies. Required. - :vartype object_id: str - :ivar application_id: Application ID of the client making request on behalf of a principal. - :vartype application_id: str - :ivar permissions: Permissions the identity has for keys, secrets and certificates. Required. - :vartype permissions: ~azure.mgmt.keyvault.v2022_07_01.models.Permissions - """ - - _validation = { - "tenant_id": {"required": True}, - "object_id": {"required": True}, - "permissions": {"required": True}, - } - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "object_id": {"key": "objectId", "type": "str"}, - "application_id": {"key": "applicationId", "type": "str"}, - "permissions": {"key": "permissions", "type": "Permissions"}, - } - - def __init__( - self, - *, - tenant_id: str, - object_id: str, - permissions: "_models.Permissions", - application_id: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :paramtype tenant_id: str - :keyword object_id: The object ID of a user, service principal or security group in the Azure - Active Directory tenant for the vault. The object ID must be unique for the list of access - policies. Required. - :paramtype object_id: str - :keyword application_id: Application ID of the client making request on behalf of a principal. - :paramtype application_id: str - :keyword permissions: Permissions the identity has for keys, secrets and certificates. - Required. - :paramtype permissions: ~azure.mgmt.keyvault.v2022_07_01.models.Permissions - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.object_id = object_id - self.application_id = application_id - self.permissions = permissions - - -class Action(_serialization.Model): - """Action. - - :ivar type: The type of the action. The value should be compared case-insensitively. Known - values are: "Rotate" and "Notify". - :vartype type: str or ~azure.mgmt.keyvault.v2022_07_01.models.KeyRotationPolicyActionType - """ - - _attribute_map = { - "type": {"key": "type", "type": "str"}, - } - - def __init__( - self, *, type: Optional[Union[str, "_models.KeyRotationPolicyActionType"]] = None, **kwargs: Any - ) -> None: - """ - :keyword type: The type of the action. The value should be compared case-insensitively. Known - values are: "Rotate" and "Notify". - :paramtype type: str or ~azure.mgmt.keyvault.v2022_07_01.models.KeyRotationPolicyActionType - """ - super().__init__(**kwargs) - self.type = type - - -class Attributes(_serialization.Model): - """The object attributes managed by the KeyVault service. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar enabled: Determines whether the object is enabled. - :vartype enabled: bool - :ivar not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :vartype not_before: ~datetime.datetime - :ivar expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :vartype expires: ~datetime.datetime - :ivar created: Creation time in seconds since 1970-01-01T00:00:00Z. - :vartype created: ~datetime.datetime - :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: ~datetime.datetime - """ - - _validation = { - "created": {"readonly": True}, - "updated": {"readonly": True}, - } - - _attribute_map = { - "enabled": {"key": "enabled", "type": "bool"}, - "not_before": {"key": "nbf", "type": "unix-time"}, - "expires": {"key": "exp", "type": "unix-time"}, - "created": {"key": "created", "type": "unix-time"}, - "updated": {"key": "updated", "type": "unix-time"}, - } - - def __init__( - self, - *, - enabled: Optional[bool] = None, - not_before: Optional[datetime.datetime] = None, - expires: Optional[datetime.datetime] = None, - **kwargs: Any - ) -> None: - """ - :keyword enabled: Determines whether the object is enabled. - :paramtype enabled: bool - :keyword not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :paramtype not_before: ~datetime.datetime - :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :paramtype expires: ~datetime.datetime - """ - super().__init__(**kwargs) - self.enabled = enabled - self.not_before = not_before - self.expires = expires - self.created = None - self.updated = None - - -class CheckMhsmNameAvailabilityParameters(_serialization.Model): - """The parameters used to check the availability of the managed hsm name. - - All required parameters must be populated in order to send to server. - - :ivar name: The managed hsm name. Required. - :vartype name: str - """ - - _validation = { - "name": {"required": True}, - } - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - } - - def __init__(self, *, name: str, **kwargs: Any) -> None: - """ - :keyword name: The managed hsm name. Required. - :paramtype name: str - """ - super().__init__(**kwargs) - self.name = name - - -class CheckMhsmNameAvailabilityResult(_serialization.Model): - """The CheckMhsmNameAvailability operation response. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar name_available: A boolean value that indicates whether the name is available for you to - use. If true, the name is available. If false, the name has already been taken or is invalid - and cannot be used. - :vartype name_available: bool - :ivar reason: The reason that a managed hsm name could not be used. The reason element is only - returned if NameAvailable is false. Known values are: "AccountNameInvalid" and "AlreadyExists". - :vartype reason: str or ~azure.mgmt.keyvault.v2022_07_01.models.Reason - :ivar message: An error message explaining the Reason value in more detail. - :vartype message: str - """ - - _validation = { - "name_available": {"readonly": True}, - "reason": {"readonly": True}, - "message": {"readonly": True}, - } - - _attribute_map = { - "name_available": {"key": "nameAvailable", "type": "bool"}, - "reason": {"key": "reason", "type": "str"}, - "message": {"key": "message", "type": "str"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.name_available = None - self.reason = None - self.message = None - - -class CheckNameAvailabilityResult(_serialization.Model): - """The CheckNameAvailability operation response. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar name_available: A boolean value that indicates whether the name is available for you to - use. If true, the name is available. If false, the name has already been taken or is invalid - and cannot be used. - :vartype name_available: bool - :ivar reason: The reason that a vault name could not be used. The Reason element is only - returned if NameAvailable is false. Known values are: "AccountNameInvalid" and "AlreadyExists". - :vartype reason: str or ~azure.mgmt.keyvault.v2022_07_01.models.Reason - :ivar message: An error message explaining the Reason value in more detail. - :vartype message: str - """ - - _validation = { - "name_available": {"readonly": True}, - "reason": {"readonly": True}, - "message": {"readonly": True}, - } - - _attribute_map = { - "name_available": {"key": "nameAvailable", "type": "bool"}, - "reason": {"key": "reason", "type": "str"}, - "message": {"key": "message", "type": "str"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.name_available = None - self.reason = None - self.message = None - - -class CloudErrorBody(_serialization.Model): - """An error response from Key Vault resource provider. - - :ivar code: Error code. This is a mnemonic that can be consumed programmatically. - :vartype code: str - :ivar message: User friendly error message. The message is typically localized and may vary - with service version. - :vartype message: str - """ - - _attribute_map = { - "code": {"key": "code", "type": "str"}, - "message": {"key": "message", "type": "str"}, - } - - def __init__(self, *, code: Optional[str] = None, message: Optional[str] = None, **kwargs: Any) -> None: - """ - :keyword code: Error code. This is a mnemonic that can be consumed programmatically. - :paramtype code: str - :keyword message: User friendly error message. The message is typically localized and may vary - with service version. - :paramtype message: str - """ - super().__init__(**kwargs) - self.code = code - self.message = message - - -class DeletedManagedHsm(_serialization.Model): - """DeletedManagedHsm. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The Azure Resource Manager resource ID for the deleted managed HSM Pool. - :vartype id: str - :ivar name: The name of the managed HSM Pool. - :vartype name: str - :ivar type: The resource type of the managed HSM Pool. - :vartype type: str - :ivar properties: Properties of the deleted managed HSM. - :vartype properties: ~azure.mgmt.keyvault.v2022_07_01.models.DeletedManagedHsmProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "properties": {"key": "properties", "type": "DeletedManagedHsmProperties"}, - } - - def __init__(self, *, properties: Optional["_models.DeletedManagedHsmProperties"] = None, **kwargs: Any) -> None: - """ - :keyword properties: Properties of the deleted managed HSM. - :paramtype properties: ~azure.mgmt.keyvault.v2022_07_01.models.DeletedManagedHsmProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.properties = properties - - -class DeletedManagedHsmListResult(_serialization.Model): - """List of deleted managed HSM Pools. - - :ivar value: The list of deleted managed HSM Pools. - :vartype value: list[~azure.mgmt.keyvault.v2022_07_01.models.DeletedManagedHsm] - :ivar next_link: The URL to get the next set of deleted managed HSM Pools. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[DeletedManagedHsm]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, - *, - value: Optional[List["_models.DeletedManagedHsm"]] = None, - next_link: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword value: The list of deleted managed HSM Pools. - :paramtype value: list[~azure.mgmt.keyvault.v2022_07_01.models.DeletedManagedHsm] - :keyword next_link: The URL to get the next set of deleted managed HSM Pools. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class DeletedManagedHsmProperties(_serialization.Model): - """Properties of the deleted managed HSM. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar mhsm_id: The resource id of the original managed HSM. - :vartype mhsm_id: str - :ivar location: The location of the original managed HSM. - :vartype location: str - :ivar deletion_date: The deleted date. - :vartype deletion_date: ~datetime.datetime - :ivar scheduled_purge_date: The scheduled purged date. - :vartype scheduled_purge_date: ~datetime.datetime - :ivar purge_protection_enabled: Purge protection status of the original managed HSM. - :vartype purge_protection_enabled: bool - :ivar tags: Tags of the original managed HSM. - :vartype tags: dict[str, str] - """ - - _validation = { - "mhsm_id": {"readonly": True}, - "location": {"readonly": True}, - "deletion_date": {"readonly": True}, - "scheduled_purge_date": {"readonly": True}, - "purge_protection_enabled": {"readonly": True}, - "tags": {"readonly": True}, - } - - _attribute_map = { - "mhsm_id": {"key": "mhsmId", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "deletion_date": {"key": "deletionDate", "type": "iso-8601"}, - "scheduled_purge_date": {"key": "scheduledPurgeDate", "type": "iso-8601"}, - "purge_protection_enabled": {"key": "purgeProtectionEnabled", "type": "bool"}, - "tags": {"key": "tags", "type": "{str}"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.mhsm_id = None - self.location = None - self.deletion_date = None - self.scheduled_purge_date = None - self.purge_protection_enabled = None - self.tags = None - - -class DeletedVault(_serialization.Model): - """Deleted vault information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The resource ID for the deleted key vault. - :vartype id: str - :ivar name: The name of the key vault. - :vartype name: str - :ivar type: The resource type of the key vault. - :vartype type: str - :ivar properties: Properties of the vault. - :vartype properties: ~azure.mgmt.keyvault.v2022_07_01.models.DeletedVaultProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "properties": {"key": "properties", "type": "DeletedVaultProperties"}, - } - - def __init__(self, *, properties: Optional["_models.DeletedVaultProperties"] = None, **kwargs: Any) -> None: - """ - :keyword properties: Properties of the vault. - :paramtype properties: ~azure.mgmt.keyvault.v2022_07_01.models.DeletedVaultProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.properties = properties - - -class DeletedVaultListResult(_serialization.Model): - """List of vaults. - - :ivar value: The list of deleted vaults. - :vartype value: list[~azure.mgmt.keyvault.v2022_07_01.models.DeletedVault] - :ivar next_link: The URL to get the next set of deleted vaults. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[DeletedVault]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.DeletedVault"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of deleted vaults. - :paramtype value: list[~azure.mgmt.keyvault.v2022_07_01.models.DeletedVault] - :keyword next_link: The URL to get the next set of deleted vaults. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class DeletedVaultProperties(_serialization.Model): - """Properties of the deleted vault. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar vault_id: The resource id of the original vault. - :vartype vault_id: str - :ivar location: The location of the original vault. - :vartype location: str - :ivar deletion_date: The deleted date. - :vartype deletion_date: ~datetime.datetime - :ivar scheduled_purge_date: The scheduled purged date. - :vartype scheduled_purge_date: ~datetime.datetime - :ivar tags: Tags of the original vault. - :vartype tags: dict[str, str] - :ivar purge_protection_enabled: Purge protection status of the original vault. - :vartype purge_protection_enabled: bool - """ - - _validation = { - "vault_id": {"readonly": True}, - "location": {"readonly": True}, - "deletion_date": {"readonly": True}, - "scheduled_purge_date": {"readonly": True}, - "tags": {"readonly": True}, - "purge_protection_enabled": {"readonly": True}, - } - - _attribute_map = { - "vault_id": {"key": "vaultId", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "deletion_date": {"key": "deletionDate", "type": "iso-8601"}, - "scheduled_purge_date": {"key": "scheduledPurgeDate", "type": "iso-8601"}, - "tags": {"key": "tags", "type": "{str}"}, - "purge_protection_enabled": {"key": "purgeProtectionEnabled", "type": "bool"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.vault_id = None - self.location = None - self.deletion_date = None - self.scheduled_purge_date = None - self.tags = None - self.purge_protection_enabled = None - - -class DimensionProperties(_serialization.Model): - """Type of operation: get, read, delete, etc. - - :ivar name: Name of dimension. - :vartype name: str - :ivar display_name: Display name of dimension. - :vartype display_name: str - :ivar to_be_exported_for_shoebox: Property to specify whether the dimension should be exported - for Shoebox. - :vartype to_be_exported_for_shoebox: bool - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display_name": {"key": "displayName", "type": "str"}, - "to_be_exported_for_shoebox": {"key": "toBeExportedForShoebox", "type": "bool"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display_name: Optional[str] = None, - to_be_exported_for_shoebox: Optional[bool] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Name of dimension. - :paramtype name: str - :keyword display_name: Display name of dimension. - :paramtype display_name: str - :keyword to_be_exported_for_shoebox: Property to specify whether the dimension should be - exported for Shoebox. - :paramtype to_be_exported_for_shoebox: bool - """ - super().__init__(**kwargs) - self.name = name - self.display_name = display_name - self.to_be_exported_for_shoebox = to_be_exported_for_shoebox - - -class Error(_serialization.Model): - """The server error. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar code: The error code. - :vartype code: str - :ivar message: The error message. - :vartype message: str - :ivar inner_error: The inner error, contains a more specific error code. - :vartype inner_error: ~azure.mgmt.keyvault.v2022_07_01.models.Error - """ - - _validation = { - "code": {"readonly": True}, - "message": {"readonly": True}, - "inner_error": {"readonly": True}, - } - - _attribute_map = { - "code": {"key": "code", "type": "str"}, - "message": {"key": "message", "type": "str"}, - "inner_error": {"key": "innererror", "type": "Error"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.code = None - self.message = None - self.inner_error = None - - -class IPRule(_serialization.Model): - """A rule governing the accessibility of a vault from a specific ip address or ip range. - - All required parameters must be populated in order to send to server. - - :ivar value: An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP address) - or '124.56.78.0/24' (all addresses that start with 124.56.78). Required. - :vartype value: str - """ - - _validation = { - "value": {"required": True}, - } - - _attribute_map = { - "value": {"key": "value", "type": "str"}, - } - - def __init__(self, *, value: str, **kwargs: Any) -> None: - """ - :keyword value: An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP - address) or '124.56.78.0/24' (all addresses that start with 124.56.78). Required. - :paramtype value: str - """ - super().__init__(**kwargs) - self.value = value - - -class Resource(_serialization.Model): - """Key Vault resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = None - self.tags = None - - -class Key(Resource): # pylint: disable=too-many-instance-attributes - """The key resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar attributes: The attributes of the key. - :vartype attributes: ~azure.mgmt.keyvault.v2022_07_01.models.KeyAttributes - :ivar kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: "EC", - "EC-HSM", "RSA", and "RSA-HSM". - :vartype kty: str or ~azure.mgmt.keyvault.v2022_07_01.models.JsonWebKeyType - :ivar key_ops: - :vartype key_ops: list[str or ~azure.mgmt.keyvault.v2022_07_01.models.JsonWebKeyOperation] - :ivar key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. - :vartype key_size: int - :ivar curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :vartype curve_name: str or ~azure.mgmt.keyvault.v2022_07_01.models.JsonWebKeyCurveName - :ivar key_uri: The URI to retrieve the current version of the key. - :vartype key_uri: str - :ivar key_uri_with_version: The URI to retrieve the specific version of the key. - :vartype key_uri_with_version: str - :ivar rotation_policy: Key rotation policy in response. It will be used for both output and - input. Omitted if empty. - :vartype rotation_policy: ~azure.mgmt.keyvault.v2022_07_01.models.RotationPolicy - :ivar release_policy: Key release policy in response. It will be used for both output and - input. Omitted if empty. - :vartype release_policy: ~azure.mgmt.keyvault.v2022_07_01.models.KeyReleasePolicy - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - "key_uri": {"readonly": True}, - "key_uri_with_version": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "attributes": {"key": "properties.attributes", "type": "KeyAttributes"}, - "kty": {"key": "properties.kty", "type": "str"}, - "key_ops": {"key": "properties.keyOps", "type": "[str]"}, - "key_size": {"key": "properties.keySize", "type": "int"}, - "curve_name": {"key": "properties.curveName", "type": "str"}, - "key_uri": {"key": "properties.keyUri", "type": "str"}, - "key_uri_with_version": {"key": "properties.keyUriWithVersion", "type": "str"}, - "rotation_policy": {"key": "properties.rotationPolicy", "type": "RotationPolicy"}, - "release_policy": {"key": "properties.release_policy", "type": "KeyReleasePolicy"}, - } - - def __init__( - self, - *, - attributes: Optional["_models.KeyAttributes"] = None, - kty: Optional[Union[str, "_models.JsonWebKeyType"]] = None, - key_ops: Optional[List[Union[str, "_models.JsonWebKeyOperation"]]] = None, - key_size: Optional[int] = None, - curve_name: Optional[Union[str, "_models.JsonWebKeyCurveName"]] = None, - rotation_policy: Optional["_models.RotationPolicy"] = None, - release_policy: Optional["_models.KeyReleasePolicy"] = None, - **kwargs: Any - ) -> None: - """ - :keyword attributes: The attributes of the key. - :paramtype attributes: ~azure.mgmt.keyvault.v2022_07_01.models.KeyAttributes - :keyword kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: - "EC", "EC-HSM", "RSA", and "RSA-HSM". - :paramtype kty: str or ~azure.mgmt.keyvault.v2022_07_01.models.JsonWebKeyType - :keyword key_ops: - :paramtype key_ops: list[str or ~azure.mgmt.keyvault.v2022_07_01.models.JsonWebKeyOperation] - :keyword key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. - :paramtype key_size: int - :keyword curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :paramtype curve_name: str or ~azure.mgmt.keyvault.v2022_07_01.models.JsonWebKeyCurveName - :keyword rotation_policy: Key rotation policy in response. It will be used for both output and - input. Omitted if empty. - :paramtype rotation_policy: ~azure.mgmt.keyvault.v2022_07_01.models.RotationPolicy - :keyword release_policy: Key release policy in response. It will be used for both output and - input. Omitted if empty. - :paramtype release_policy: ~azure.mgmt.keyvault.v2022_07_01.models.KeyReleasePolicy - """ - super().__init__(**kwargs) - self.attributes = attributes - self.kty = kty - self.key_ops = key_ops - self.key_size = key_size - self.curve_name = curve_name - self.key_uri = None - self.key_uri_with_version = None - self.rotation_policy = rotation_policy - self.release_policy = release_policy - - -class KeyAttributes(_serialization.Model): - """The object attributes managed by the Azure Key Vault service. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar enabled: Determines whether or not the object is enabled. - :vartype enabled: bool - :ivar not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :vartype not_before: int - :ivar expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :vartype expires: int - :ivar created: Creation time in seconds since 1970-01-01T00:00:00Z. - :vartype created: int - :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: int - :ivar recovery_level: The deletion recovery level currently in effect for the object. If it - contains 'Purgeable', then the object can be permanently deleted by a privileged user; - otherwise, only the system can purge the object at the end of the retention interval. Known - values are: "Purgeable", "Recoverable+Purgeable", "Recoverable", and - "Recoverable+ProtectedSubscription". - :vartype recovery_level: str or ~azure.mgmt.keyvault.v2022_07_01.models.DeletionRecoveryLevel - :ivar exportable: Indicates if the private key can be exported. - :vartype exportable: bool - """ - - _validation = { - "created": {"readonly": True}, - "updated": {"readonly": True}, - "recovery_level": {"readonly": True}, - } - - _attribute_map = { - "enabled": {"key": "enabled", "type": "bool"}, - "not_before": {"key": "nbf", "type": "int"}, - "expires": {"key": "exp", "type": "int"}, - "created": {"key": "created", "type": "int"}, - "updated": {"key": "updated", "type": "int"}, - "recovery_level": {"key": "recoveryLevel", "type": "str"}, - "exportable": {"key": "exportable", "type": "bool"}, - } - - def __init__( - self, - *, - enabled: Optional[bool] = None, - not_before: Optional[int] = None, - expires: Optional[int] = None, - exportable: bool = False, - **kwargs: Any - ) -> None: - """ - :keyword enabled: Determines whether or not the object is enabled. - :paramtype enabled: bool - :keyword not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :paramtype not_before: int - :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :paramtype expires: int - :keyword exportable: Indicates if the private key can be exported. - :paramtype exportable: bool - """ - super().__init__(**kwargs) - self.enabled = enabled - self.not_before = not_before - self.expires = expires - self.created = None - self.updated = None - self.recovery_level = None - self.exportable = exportable - - -class KeyCreateParameters(_serialization.Model): - """The parameters used to create a key. - - All required parameters must be populated in order to send to server. - - :ivar tags: The tags that will be assigned to the key. - :vartype tags: dict[str, str] - :ivar properties: The properties of the key to be created. Required. - :vartype properties: ~azure.mgmt.keyvault.v2022_07_01.models.KeyProperties - """ - - _validation = { - "properties": {"required": True}, - } - - _attribute_map = { - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "KeyProperties"}, - } - - def __init__( - self, *, properties: "_models.KeyProperties", tags: Optional[Dict[str, str]] = None, **kwargs: Any - ) -> None: - """ - :keyword tags: The tags that will be assigned to the key. - :paramtype tags: dict[str, str] - :keyword properties: The properties of the key to be created. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2022_07_01.models.KeyProperties - """ - super().__init__(**kwargs) - self.tags = tags - self.properties = properties - - -class KeyListResult(_serialization.Model): - """The page of keys. - - :ivar value: The key resources. - :vartype value: list[~azure.mgmt.keyvault.v2022_07_01.models.Key] - :ivar next_link: The URL to get the next page of keys. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Key]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Key"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The key resources. - :paramtype value: list[~azure.mgmt.keyvault.v2022_07_01.models.Key] - :keyword next_link: The URL to get the next page of keys. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class KeyProperties(_serialization.Model): - """The properties of the key. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar attributes: The attributes of the key. - :vartype attributes: ~azure.mgmt.keyvault.v2022_07_01.models.KeyAttributes - :ivar kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: "EC", - "EC-HSM", "RSA", and "RSA-HSM". - :vartype kty: str or ~azure.mgmt.keyvault.v2022_07_01.models.JsonWebKeyType - :ivar key_ops: - :vartype key_ops: list[str or ~azure.mgmt.keyvault.v2022_07_01.models.JsonWebKeyOperation] - :ivar key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. - :vartype key_size: int - :ivar curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :vartype curve_name: str or ~azure.mgmt.keyvault.v2022_07_01.models.JsonWebKeyCurveName - :ivar key_uri: The URI to retrieve the current version of the key. - :vartype key_uri: str - :ivar key_uri_with_version: The URI to retrieve the specific version of the key. - :vartype key_uri_with_version: str - :ivar rotation_policy: Key rotation policy in response. It will be used for both output and - input. Omitted if empty. - :vartype rotation_policy: ~azure.mgmt.keyvault.v2022_07_01.models.RotationPolicy - :ivar release_policy: Key release policy in response. It will be used for both output and - input. Omitted if empty. - :vartype release_policy: ~azure.mgmt.keyvault.v2022_07_01.models.KeyReleasePolicy - """ - - _validation = { - "key_uri": {"readonly": True}, - "key_uri_with_version": {"readonly": True}, - } - - _attribute_map = { - "attributes": {"key": "attributes", "type": "KeyAttributes"}, - "kty": {"key": "kty", "type": "str"}, - "key_ops": {"key": "keyOps", "type": "[str]"}, - "key_size": {"key": "keySize", "type": "int"}, - "curve_name": {"key": "curveName", "type": "str"}, - "key_uri": {"key": "keyUri", "type": "str"}, - "key_uri_with_version": {"key": "keyUriWithVersion", "type": "str"}, - "rotation_policy": {"key": "rotationPolicy", "type": "RotationPolicy"}, - "release_policy": {"key": "release_policy", "type": "KeyReleasePolicy"}, - } - - def __init__( - self, - *, - attributes: Optional["_models.KeyAttributes"] = None, - kty: Optional[Union[str, "_models.JsonWebKeyType"]] = None, - key_ops: Optional[List[Union[str, "_models.JsonWebKeyOperation"]]] = None, - key_size: Optional[int] = None, - curve_name: Optional[Union[str, "_models.JsonWebKeyCurveName"]] = None, - rotation_policy: Optional["_models.RotationPolicy"] = None, - release_policy: Optional["_models.KeyReleasePolicy"] = None, - **kwargs: Any - ) -> None: - """ - :keyword attributes: The attributes of the key. - :paramtype attributes: ~azure.mgmt.keyvault.v2022_07_01.models.KeyAttributes - :keyword kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: - "EC", "EC-HSM", "RSA", and "RSA-HSM". - :paramtype kty: str or ~azure.mgmt.keyvault.v2022_07_01.models.JsonWebKeyType - :keyword key_ops: - :paramtype key_ops: list[str or ~azure.mgmt.keyvault.v2022_07_01.models.JsonWebKeyOperation] - :keyword key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. - :paramtype key_size: int - :keyword curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :paramtype curve_name: str or ~azure.mgmt.keyvault.v2022_07_01.models.JsonWebKeyCurveName - :keyword rotation_policy: Key rotation policy in response. It will be used for both output and - input. Omitted if empty. - :paramtype rotation_policy: ~azure.mgmt.keyvault.v2022_07_01.models.RotationPolicy - :keyword release_policy: Key release policy in response. It will be used for both output and - input. Omitted if empty. - :paramtype release_policy: ~azure.mgmt.keyvault.v2022_07_01.models.KeyReleasePolicy - """ - super().__init__(**kwargs) - self.attributes = attributes - self.kty = kty - self.key_ops = key_ops - self.key_size = key_size - self.curve_name = curve_name - self.key_uri = None - self.key_uri_with_version = None - self.rotation_policy = rotation_policy - self.release_policy = release_policy - - -class KeyReleasePolicy(_serialization.Model): - """KeyReleasePolicy. - - :ivar content_type: Content type and version of key release policy. - :vartype content_type: str - :ivar data: Blob encoding the policy rules under which the key can be released. - :vartype data: bytes - """ - - _attribute_map = { - "content_type": {"key": "contentType", "type": "str"}, - "data": {"key": "data", "type": "base64"}, - } - - def __init__( - self, *, content_type: str = "application/json; charset=utf-8", data: Optional[bytes] = None, **kwargs: Any - ) -> None: - """ - :keyword content_type: Content type and version of key release policy. - :paramtype content_type: str - :keyword data: Blob encoding the policy rules under which the key can be released. - :paramtype data: bytes - """ - super().__init__(**kwargs) - self.content_type = content_type - self.data = data - - -class KeyRotationPolicyAttributes(_serialization.Model): - """KeyRotationPolicyAttributes. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar created: Creation time in seconds since 1970-01-01T00:00:00Z. - :vartype created: int - :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: int - :ivar expiry_time: The expiration time for the new key version. It should be in ISO8601 format. - Eg: 'P90D', 'P1Y'. - :vartype expiry_time: str - """ - - _validation = { - "created": {"readonly": True}, - "updated": {"readonly": True}, - } - - _attribute_map = { - "created": {"key": "created", "type": "int"}, - "updated": {"key": "updated", "type": "int"}, - "expiry_time": {"key": "expiryTime", "type": "str"}, - } - - def __init__(self, *, expiry_time: Optional[str] = None, **kwargs: Any) -> None: - """ - :keyword expiry_time: The expiration time for the new key version. It should be in ISO8601 - format. Eg: 'P90D', 'P1Y'. - :paramtype expiry_time: str - """ - super().__init__(**kwargs) - self.created = None - self.updated = None - self.expiry_time = expiry_time - - -class LifetimeAction(_serialization.Model): - """LifetimeAction. - - :ivar trigger: The trigger of key rotation policy lifetimeAction. - :vartype trigger: ~azure.mgmt.keyvault.v2022_07_01.models.Trigger - :ivar action: The action of key rotation policy lifetimeAction. - :vartype action: ~azure.mgmt.keyvault.v2022_07_01.models.Action - """ - - _attribute_map = { - "trigger": {"key": "trigger", "type": "Trigger"}, - "action": {"key": "action", "type": "Action"}, - } - - def __init__( - self, *, trigger: Optional["_models.Trigger"] = None, action: Optional["_models.Action"] = None, **kwargs: Any - ) -> None: - """ - :keyword trigger: The trigger of key rotation policy lifetimeAction. - :paramtype trigger: ~azure.mgmt.keyvault.v2022_07_01.models.Trigger - :keyword action: The action of key rotation policy lifetimeAction. - :paramtype action: ~azure.mgmt.keyvault.v2022_07_01.models.Action - """ - super().__init__(**kwargs) - self.trigger = trigger - self.action = action - - -class LogSpecification(_serialization.Model): - """Log specification of operation. - - :ivar name: Name of log specification. - :vartype name: str - :ivar display_name: Display name of log specification. - :vartype display_name: str - :ivar blob_duration: Blob duration of specification. - :vartype blob_duration: str - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display_name": {"key": "displayName", "type": "str"}, - "blob_duration": {"key": "blobDuration", "type": "str"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display_name: Optional[str] = None, - blob_duration: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Name of log specification. - :paramtype name: str - :keyword display_name: Display name of log specification. - :paramtype display_name: str - :keyword blob_duration: Blob duration of specification. - :paramtype blob_duration: str - """ - super().__init__(**kwargs) - self.name = name - self.display_name = display_name - self.blob_duration = blob_duration - - -class ManagedHsmResource(_serialization.Model): - """Managed HSM resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The Azure Resource Manager resource ID for the managed HSM Pool. - :vartype id: str - :ivar name: The name of the managed HSM Pool. - :vartype name: str - :ivar type: The resource type of the managed HSM Pool. - :vartype type: str - :ivar location: The supported Azure location where the managed HSM Pool should be created. - :vartype location: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSku - :ivar tags: Resource tags. - :vartype tags: dict[str, str] - :ivar system_data: Metadata pertaining to creation and last modification of the key vault - resource. - :vartype system_data: ~azure.mgmt.keyvault.v2022_07_01.models.SystemData - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "system_data": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "sku": {"key": "sku", "type": "ManagedHsmSku"}, - "tags": {"key": "tags", "type": "{str}"}, - "system_data": {"key": "systemData", "type": "SystemData"}, - } - - def __init__( - self, - *, - location: Optional[str] = None, - sku: Optional["_models.ManagedHsmSku"] = None, - tags: Optional[Dict[str, str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the managed HSM Pool should be created. - :paramtype location: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSku - :keyword tags: Resource tags. - :paramtype tags: dict[str, str] - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = location - self.sku = sku - self.tags = tags - self.system_data = None - - -class ManagedHsm(ManagedHsmResource): - """Resource information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The Azure Resource Manager resource ID for the managed HSM Pool. - :vartype id: str - :ivar name: The name of the managed HSM Pool. - :vartype name: str - :ivar type: The resource type of the managed HSM Pool. - :vartype type: str - :ivar location: The supported Azure location where the managed HSM Pool should be created. - :vartype location: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSku - :ivar tags: Resource tags. - :vartype tags: dict[str, str] - :ivar system_data: Metadata pertaining to creation and last modification of the key vault - resource. - :vartype system_data: ~azure.mgmt.keyvault.v2022_07_01.models.SystemData - :ivar properties: Properties of the managed HSM. - :vartype properties: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "system_data": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "sku": {"key": "sku", "type": "ManagedHsmSku"}, - "tags": {"key": "tags", "type": "{str}"}, - "system_data": {"key": "systemData", "type": "SystemData"}, - "properties": {"key": "properties", "type": "ManagedHsmProperties"}, - } - - def __init__( - self, - *, - location: Optional[str] = None, - sku: Optional["_models.ManagedHsmSku"] = None, - tags: Optional[Dict[str, str]] = None, - properties: Optional["_models.ManagedHsmProperties"] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the managed HSM Pool should be created. - :paramtype location: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSku - :keyword tags: Resource tags. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the managed HSM. - :paramtype properties: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmProperties - """ - super().__init__(location=location, sku=sku, tags=tags, **kwargs) - self.properties = properties - - -class ManagedHsmError(_serialization.Model): - """The error exception. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar error: The server error. - :vartype error: ~azure.mgmt.keyvault.v2022_07_01.models.Error - """ - - _validation = { - "error": {"readonly": True}, - } - - _attribute_map = { - "error": {"key": "error", "type": "Error"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.error = None - - -class ManagedHsmListResult(_serialization.Model): - """List of managed HSM Pools. - - :ivar value: The list of managed HSM Pools. - :vartype value: list[~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm] - :ivar next_link: The URL to get the next set of managed HSM Pools. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[ManagedHsm]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.ManagedHsm"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of managed HSM Pools. - :paramtype value: list[~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm] - :keyword next_link: The URL to get the next set of managed HSM Pools. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class ManagedHsmProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Properties of the managed HSM Pool. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the managed HSM pool. - :vartype tenant_id: str - :ivar initial_admin_object_ids: Array of initial administrators object ids for this managed hsm - pool. - :vartype initial_admin_object_ids: list[str] - :ivar hsm_uri: The URI of the managed hsm pool for performing operations on keys. - :vartype hsm_uri: str - :ivar enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this managed HSM pool. Soft delete is enabled by default for all managed HSMs and - is immutable. - :vartype enable_soft_delete: bool - :ivar soft_delete_retention_in_days: Soft deleted data retention days. When you delete an HSM - or a key, it will remain recoverable for the configured retention period or for a default - period of 90 days. It accepts values between 7 and 90. - :vartype soft_delete_retention_in_days: int - :ivar enable_purge_protection: Property specifying whether protection against purge is enabled - for this managed HSM pool. Setting this property to true activates protection against purge for - this managed HSM pool and its content - only the Managed HSM service may initiate a hard, - irrecoverable deletion. Enabling this functionality is irreversible. - :vartype enable_purge_protection: bool - :ivar create_mode: The create mode to indicate whether the resource is being created or is - being recovered from a deleted resource. Known values are: "recover" and "default". - :vartype create_mode: str or ~azure.mgmt.keyvault.v2022_07_01.models.CreateMode - :ivar status_message: Resource Status Message. - :vartype status_message: str - :ivar provisioning_state: Provisioning state. Known values are: "Succeeded", "Provisioning", - "Failed", "Updating", "Deleting", "Activated", "SecurityDomainRestore", and "Restoring". - :vartype provisioning_state: str or ~azure.mgmt.keyvault.v2022_07_01.models.ProvisioningState - :ivar network_acls: Rules governing the accessibility of the key vault from specific network - locations. - :vartype network_acls: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMNetworkRuleSet - :ivar private_endpoint_connections: List of private endpoint connections associated with the - managed hsm pool. - :vartype private_endpoint_connections: - list[~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnectionItem] - :ivar public_network_access: Control permission to the managed HSM from public networks. Known - values are: "Enabled" and "Disabled". - :vartype public_network_access: str or - ~azure.mgmt.keyvault.v2022_07_01.models.PublicNetworkAccess - :ivar scheduled_purge_date: The scheduled purge date in UTC. - :vartype scheduled_purge_date: ~datetime.datetime - :ivar security_domain_properties: Managed HSM security domain properties. - :vartype security_domain_properties: - ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHSMSecurityDomainProperties - """ - - _validation = { - "hsm_uri": {"readonly": True}, - "status_message": {"readonly": True}, - "provisioning_state": {"readonly": True}, - "private_endpoint_connections": {"readonly": True}, - "scheduled_purge_date": {"readonly": True}, - "security_domain_properties": {"readonly": True}, - } - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "initial_admin_object_ids": {"key": "initialAdminObjectIds", "type": "[str]"}, - "hsm_uri": {"key": "hsmUri", "type": "str"}, - "enable_soft_delete": {"key": "enableSoftDelete", "type": "bool"}, - "soft_delete_retention_in_days": {"key": "softDeleteRetentionInDays", "type": "int"}, - "enable_purge_protection": {"key": "enablePurgeProtection", "type": "bool"}, - "create_mode": {"key": "createMode", "type": "str"}, - "status_message": {"key": "statusMessage", "type": "str"}, - "provisioning_state": {"key": "provisioningState", "type": "str"}, - "network_acls": {"key": "networkAcls", "type": "MHSMNetworkRuleSet"}, - "private_endpoint_connections": { - "key": "privateEndpointConnections", - "type": "[MHSMPrivateEndpointConnectionItem]", - }, - "public_network_access": {"key": "publicNetworkAccess", "type": "str"}, - "scheduled_purge_date": {"key": "scheduledPurgeDate", "type": "iso-8601"}, - "security_domain_properties": {"key": "securityDomainProperties", "type": "ManagedHSMSecurityDomainProperties"}, - } - - def __init__( - self, - *, - tenant_id: Optional[str] = None, - initial_admin_object_ids: Optional[List[str]] = None, - enable_soft_delete: bool = True, - soft_delete_retention_in_days: int = 90, - enable_purge_protection: bool = True, - create_mode: Optional[Union[str, "_models.CreateMode"]] = None, - network_acls: Optional["_models.MHSMNetworkRuleSet"] = None, - public_network_access: Union[str, "_models.PublicNetworkAccess"] = "Enabled", - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the managed HSM pool. - :paramtype tenant_id: str - :keyword initial_admin_object_ids: Array of initial administrators object ids for this managed - hsm pool. - :paramtype initial_admin_object_ids: list[str] - :keyword enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this managed HSM pool. Soft delete is enabled by default for all managed HSMs and - is immutable. - :paramtype enable_soft_delete: bool - :keyword soft_delete_retention_in_days: Soft deleted data retention days. When you delete an - HSM or a key, it will remain recoverable for the configured retention period or for a default - period of 90 days. It accepts values between 7 and 90. - :paramtype soft_delete_retention_in_days: int - :keyword enable_purge_protection: Property specifying whether protection against purge is - enabled for this managed HSM pool. Setting this property to true activates protection against - purge for this managed HSM pool and its content - only the Managed HSM service may initiate a - hard, irrecoverable deletion. Enabling this functionality is irreversible. - :paramtype enable_purge_protection: bool - :keyword create_mode: The create mode to indicate whether the resource is being created or is - being recovered from a deleted resource. Known values are: "recover" and "default". - :paramtype create_mode: str or ~azure.mgmt.keyvault.v2022_07_01.models.CreateMode - :keyword network_acls: Rules governing the accessibility of the key vault from specific network - locations. - :paramtype network_acls: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMNetworkRuleSet - :keyword public_network_access: Control permission to the managed HSM from public networks. - Known values are: "Enabled" and "Disabled". - :paramtype public_network_access: str or - ~azure.mgmt.keyvault.v2022_07_01.models.PublicNetworkAccess - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.initial_admin_object_ids = initial_admin_object_ids - self.hsm_uri = None - self.enable_soft_delete = enable_soft_delete - self.soft_delete_retention_in_days = soft_delete_retention_in_days - self.enable_purge_protection = enable_purge_protection - self.create_mode = create_mode - self.status_message = None - self.provisioning_state = None - self.network_acls = network_acls - self.private_endpoint_connections = None - self.public_network_access = public_network_access - self.scheduled_purge_date = None - self.security_domain_properties = None - - -class ManagedHSMSecurityDomainProperties(_serialization.Model): - """The security domain properties of the managed hsm. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar activation_status: Activation Status. Known values are: "Active", "NotActivated", - "Unknown", and "Failed". - :vartype activation_status: str or ~azure.mgmt.keyvault.v2022_07_01.models.ActivationStatus - :ivar activation_status_message: Activation Status Message. - :vartype activation_status_message: str - """ - - _validation = { - "activation_status": {"readonly": True}, - "activation_status_message": {"readonly": True}, - } - - _attribute_map = { - "activation_status": {"key": "activationStatus", "type": "str"}, - "activation_status_message": {"key": "activationStatusMessage", "type": "str"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.activation_status = None - self.activation_status_message = None - - -class ManagedHsmSku(_serialization.Model): - """SKU details. - - All required parameters must be populated in order to send to server. - - :ivar family: SKU Family of the managed HSM Pool. "B" - :vartype family: str or ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSkuFamily - :ivar name: SKU of the managed HSM Pool. Required. Known values are: "Standard_B1", - "Custom_B32", and "Custom_B6". - :vartype name: str or ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSkuName - """ - - _validation = { - "family": {"required": True}, - "name": {"required": True}, - } - - _attribute_map = { - "family": {"key": "family", "type": "str"}, - "name": {"key": "name", "type": "str"}, - } - - def __init__( - self, - *, - family: Union[str, "_models.ManagedHsmSkuFamily"] = "B", - name: Union[str, "_models.ManagedHsmSkuName"], - **kwargs: Any - ) -> None: - """ - :keyword family: SKU Family of the managed HSM Pool. "B" - :paramtype family: str or ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSkuFamily - :keyword name: SKU of the managed HSM Pool. Required. Known values are: "Standard_B1", - "Custom_B32", and "Custom_B6". - :paramtype name: str or ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSkuName - """ - super().__init__(**kwargs) - self.family = family - self.name = name - - -class MetricSpecification(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Metric specification of operation. - - :ivar name: Name of metric specification. - :vartype name: str - :ivar display_name: Display name of metric specification. - :vartype display_name: str - :ivar display_description: Display description of metric specification. - :vartype display_description: str - :ivar unit: The metric unit. Possible values include: 'Bytes', 'Count', 'Milliseconds'. - :vartype unit: str - :ivar aggregation_type: The metric aggregation type. Possible values include: 'Average', - 'Count', 'Total'. - :vartype aggregation_type: str - :ivar supported_aggregation_types: The supported aggregation types for the metrics. - :vartype supported_aggregation_types: list[str] - :ivar supported_time_grain_types: The supported time grain types for the metrics. - :vartype supported_time_grain_types: list[str] - :ivar lock_aggregation_type: The metric lock aggregation type. - :vartype lock_aggregation_type: str - :ivar dimensions: The dimensions of metric. - :vartype dimensions: list[~azure.mgmt.keyvault.v2022_07_01.models.DimensionProperties] - :ivar fill_gap_with_zero: Property to specify whether to fill gap with zero. - :vartype fill_gap_with_zero: bool - :ivar internal_metric_name: The internal metric name. - :vartype internal_metric_name: str - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display_name": {"key": "displayName", "type": "str"}, - "display_description": {"key": "displayDescription", "type": "str"}, - "unit": {"key": "unit", "type": "str"}, - "aggregation_type": {"key": "aggregationType", "type": "str"}, - "supported_aggregation_types": {"key": "supportedAggregationTypes", "type": "[str]"}, - "supported_time_grain_types": {"key": "supportedTimeGrainTypes", "type": "[str]"}, - "lock_aggregation_type": {"key": "lockAggregationType", "type": "str"}, - "dimensions": {"key": "dimensions", "type": "[DimensionProperties]"}, - "fill_gap_with_zero": {"key": "fillGapWithZero", "type": "bool"}, - "internal_metric_name": {"key": "internalMetricName", "type": "str"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display_name: Optional[str] = None, - display_description: Optional[str] = None, - unit: Optional[str] = None, - aggregation_type: Optional[str] = None, - supported_aggregation_types: Optional[List[str]] = None, - supported_time_grain_types: Optional[List[str]] = None, - lock_aggregation_type: Optional[str] = None, - dimensions: Optional[List["_models.DimensionProperties"]] = None, - fill_gap_with_zero: Optional[bool] = None, - internal_metric_name: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Name of metric specification. - :paramtype name: str - :keyword display_name: Display name of metric specification. - :paramtype display_name: str - :keyword display_description: Display description of metric specification. - :paramtype display_description: str - :keyword unit: The metric unit. Possible values include: 'Bytes', 'Count', 'Milliseconds'. - :paramtype unit: str - :keyword aggregation_type: The metric aggregation type. Possible values include: 'Average', - 'Count', 'Total'. - :paramtype aggregation_type: str - :keyword supported_aggregation_types: The supported aggregation types for the metrics. - :paramtype supported_aggregation_types: list[str] - :keyword supported_time_grain_types: The supported time grain types for the metrics. - :paramtype supported_time_grain_types: list[str] - :keyword lock_aggregation_type: The metric lock aggregation type. - :paramtype lock_aggregation_type: str - :keyword dimensions: The dimensions of metric. - :paramtype dimensions: list[~azure.mgmt.keyvault.v2022_07_01.models.DimensionProperties] - :keyword fill_gap_with_zero: Property to specify whether to fill gap with zero. - :paramtype fill_gap_with_zero: bool - :keyword internal_metric_name: The internal metric name. - :paramtype internal_metric_name: str - """ - super().__init__(**kwargs) - self.name = name - self.display_name = display_name - self.display_description = display_description - self.unit = unit - self.aggregation_type = aggregation_type - self.supported_aggregation_types = supported_aggregation_types - self.supported_time_grain_types = supported_time_grain_types - self.lock_aggregation_type = lock_aggregation_type - self.dimensions = dimensions - self.fill_gap_with_zero = fill_gap_with_zero - self.internal_metric_name = internal_metric_name - - -class MHSMIPRule(_serialization.Model): - """A rule governing the accessibility of a managed hsm pool from a specific ip address or ip - range. - - All required parameters must be populated in order to send to server. - - :ivar value: An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP address) - or '124.56.78.0/24' (all addresses that start with 124.56.78). Required. - :vartype value: str - """ - - _validation = { - "value": {"required": True}, - } - - _attribute_map = { - "value": {"key": "value", "type": "str"}, - } - - def __init__(self, *, value: str, **kwargs: Any) -> None: - """ - :keyword value: An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP - address) or '124.56.78.0/24' (all addresses that start with 124.56.78). Required. - :paramtype value: str - """ - super().__init__(**kwargs) - self.value = value - - -class MHSMNetworkRuleSet(_serialization.Model): - """A set of rules governing the network accessibility of a managed hsm pool. - - :ivar bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or - 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and - "None". - :vartype bypass: str or ~azure.mgmt.keyvault.v2022_07_01.models.NetworkRuleBypassOptions - :ivar default_action: The default action when no rule from ipRules and from virtualNetworkRules - match. This is only used after the bypass property has been evaluated. Known values are: - "Allow" and "Deny". - :vartype default_action: str or ~azure.mgmt.keyvault.v2022_07_01.models.NetworkRuleAction - :ivar ip_rules: The list of IP address rules. - :vartype ip_rules: list[~azure.mgmt.keyvault.v2022_07_01.models.MHSMIPRule] - :ivar virtual_network_rules: The list of virtual network rules. - :vartype virtual_network_rules: - list[~azure.mgmt.keyvault.v2022_07_01.models.MHSMVirtualNetworkRule] - """ - - _attribute_map = { - "bypass": {"key": "bypass", "type": "str"}, - "default_action": {"key": "defaultAction", "type": "str"}, - "ip_rules": {"key": "ipRules", "type": "[MHSMIPRule]"}, - "virtual_network_rules": {"key": "virtualNetworkRules", "type": "[MHSMVirtualNetworkRule]"}, - } - - def __init__( - self, - *, - bypass: Optional[Union[str, "_models.NetworkRuleBypassOptions"]] = None, - default_action: Optional[Union[str, "_models.NetworkRuleAction"]] = None, - ip_rules: Optional[List["_models.MHSMIPRule"]] = None, - virtual_network_rules: Optional[List["_models.MHSMVirtualNetworkRule"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or - 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and - "None". - :paramtype bypass: str or ~azure.mgmt.keyvault.v2022_07_01.models.NetworkRuleBypassOptions - :keyword default_action: The default action when no rule from ipRules and from - virtualNetworkRules match. This is only used after the bypass property has been evaluated. - Known values are: "Allow" and "Deny". - :paramtype default_action: str or ~azure.mgmt.keyvault.v2022_07_01.models.NetworkRuleAction - :keyword ip_rules: The list of IP address rules. - :paramtype ip_rules: list[~azure.mgmt.keyvault.v2022_07_01.models.MHSMIPRule] - :keyword virtual_network_rules: The list of virtual network rules. - :paramtype virtual_network_rules: - list[~azure.mgmt.keyvault.v2022_07_01.models.MHSMVirtualNetworkRule] - """ - super().__init__(**kwargs) - self.bypass = bypass - self.default_action = default_action - self.ip_rules = ip_rules - self.virtual_network_rules = virtual_network_rules - - -class MHSMPrivateEndpoint(_serialization.Model): - """Private endpoint object properties. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Full identifier of the private endpoint resource. - :vartype id: str - """ - - _validation = { - "id": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.id = None - - -class MHSMPrivateEndpointConnection(ManagedHsmResource): # pylint: disable=too-many-instance-attributes - """Private endpoint connection resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The Azure Resource Manager resource ID for the managed HSM Pool. - :vartype id: str - :ivar name: The name of the managed HSM Pool. - :vartype name: str - :ivar type: The resource type of the managed HSM Pool. - :vartype type: str - :ivar location: The supported Azure location where the managed HSM Pool should be created. - :vartype location: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSku - :ivar tags: Resource tags. - :vartype tags: dict[str, str] - :ivar system_data: Metadata pertaining to creation and last modification of the key vault - resource. - :vartype system_data: ~azure.mgmt.keyvault.v2022_07_01.models.SystemData - :ivar etag: Modified whenever there is a change in the state of private endpoint connection. - :vartype etag: str - :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpoint - :ivar private_link_service_connection_state: Approval state of the private link connection. - :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateLinkServiceConnectionState - :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values - are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnectionProvisioningState - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "system_data": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "sku": {"key": "sku", "type": "ManagedHsmSku"}, - "tags": {"key": "tags", "type": "{str}"}, - "system_data": {"key": "systemData", "type": "SystemData"}, - "etag": {"key": "etag", "type": "str"}, - "private_endpoint": {"key": "properties.privateEndpoint", "type": "MHSMPrivateEndpoint"}, - "private_link_service_connection_state": { - "key": "properties.privateLinkServiceConnectionState", - "type": "MHSMPrivateLinkServiceConnectionState", - }, - "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - location: Optional[str] = None, - sku: Optional["_models.ManagedHsmSku"] = None, - tags: Optional[Dict[str, str]] = None, - etag: Optional[str] = None, - private_endpoint: Optional["_models.MHSMPrivateEndpoint"] = None, - private_link_service_connection_state: Optional["_models.MHSMPrivateLinkServiceConnectionState"] = None, - provisioning_state: Optional[Union[str, "_models.PrivateEndpointConnectionProvisioningState"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the managed HSM Pool should be created. - :paramtype location: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSku - :keyword tags: Resource tags. - :paramtype tags: dict[str, str] - :keyword etag: Modified whenever there is a change in the state of private endpoint connection. - :paramtype etag: str - :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpoint - :keyword private_link_service_connection_state: Approval state of the private link connection. - :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateLinkServiceConnectionState - :keyword provisioning_state: Provisioning state of the private endpoint connection. Known - values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnectionProvisioningState - """ - super().__init__(location=location, sku=sku, tags=tags, **kwargs) - self.etag = etag - self.private_endpoint = private_endpoint - self.private_link_service_connection_state = private_link_service_connection_state - self.provisioning_state = provisioning_state - - -class MHSMPrivateEndpointConnectionItem(_serialization.Model): - """Private endpoint connection item. - - :ivar id: Id of private endpoint connection. - :vartype id: str - :ivar etag: Modified whenever there is a change in the state of private endpoint connection. - :vartype etag: str - :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpoint - :ivar private_link_service_connection_state: Approval state of the private link connection. - :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateLinkServiceConnectionState - :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values - are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnectionProvisioningState - """ - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "etag": {"key": "etag", "type": "str"}, - "private_endpoint": {"key": "properties.privateEndpoint", "type": "MHSMPrivateEndpoint"}, - "private_link_service_connection_state": { - "key": "properties.privateLinkServiceConnectionState", - "type": "MHSMPrivateLinkServiceConnectionState", - }, - "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - id: Optional[str] = None, # pylint: disable=redefined-builtin - etag: Optional[str] = None, - private_endpoint: Optional["_models.MHSMPrivateEndpoint"] = None, - private_link_service_connection_state: Optional["_models.MHSMPrivateLinkServiceConnectionState"] = None, - provisioning_state: Optional[Union[str, "_models.PrivateEndpointConnectionProvisioningState"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword id: Id of private endpoint connection. - :paramtype id: str - :keyword etag: Modified whenever there is a change in the state of private endpoint connection. - :paramtype etag: str - :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpoint - :keyword private_link_service_connection_state: Approval state of the private link connection. - :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateLinkServiceConnectionState - :keyword provisioning_state: Provisioning state of the private endpoint connection. Known - values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnectionProvisioningState - """ - super().__init__(**kwargs) - self.id = id - self.etag = etag - self.private_endpoint = private_endpoint - self.private_link_service_connection_state = private_link_service_connection_state - self.provisioning_state = provisioning_state - - -class MHSMPrivateEndpointConnectionsListResult(_serialization.Model): - """List of private endpoint connections associated with a managed HSM Pools. - - :ivar value: The private endpoint connection associated with a managed HSM Pools. - :vartype value: list[~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection] - :ivar next_link: The URL to get the next set of managed HSM Pools. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[MHSMPrivateEndpointConnection]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, - *, - value: Optional[List["_models.MHSMPrivateEndpointConnection"]] = None, - next_link: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword value: The private endpoint connection associated with a managed HSM Pools. - :paramtype value: list[~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection] - :keyword next_link: The URL to get the next set of managed HSM Pools. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class MHSMPrivateLinkResource(ManagedHsmResource): - """A private link resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: The Azure Resource Manager resource ID for the managed HSM Pool. - :vartype id: str - :ivar name: The name of the managed HSM Pool. - :vartype name: str - :ivar type: The resource type of the managed HSM Pool. - :vartype type: str - :ivar location: The supported Azure location where the managed HSM Pool should be created. - :vartype location: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSku - :ivar tags: Resource tags. - :vartype tags: dict[str, str] - :ivar system_data: Metadata pertaining to creation and last modification of the key vault - resource. - :vartype system_data: ~azure.mgmt.keyvault.v2022_07_01.models.SystemData - :ivar group_id: Group identifier of private link resource. - :vartype group_id: str - :ivar required_members: Required member names of private link resource. - :vartype required_members: list[str] - :ivar required_zone_names: Required DNS zone names of the the private link resource. - :vartype required_zone_names: list[str] - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "system_data": {"readonly": True}, - "group_id": {"readonly": True}, - "required_members": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "sku": {"key": "sku", "type": "ManagedHsmSku"}, - "tags": {"key": "tags", "type": "{str}"}, - "system_data": {"key": "systemData", "type": "SystemData"}, - "group_id": {"key": "properties.groupId", "type": "str"}, - "required_members": {"key": "properties.requiredMembers", "type": "[str]"}, - "required_zone_names": {"key": "properties.requiredZoneNames", "type": "[str]"}, - } - - def __init__( - self, - *, - location: Optional[str] = None, - sku: Optional["_models.ManagedHsmSku"] = None, - tags: Optional[Dict[str, str]] = None, - required_zone_names: Optional[List[str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the managed HSM Pool should be created. - :paramtype location: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSku - :keyword tags: Resource tags. - :paramtype tags: dict[str, str] - :keyword required_zone_names: Required DNS zone names of the the private link resource. - :paramtype required_zone_names: list[str] - """ - super().__init__(location=location, sku=sku, tags=tags, **kwargs) - self.group_id = None - self.required_members = None - self.required_zone_names = required_zone_names - - -class MHSMPrivateLinkResourceListResult(_serialization.Model): - """A list of private link resources. - - :ivar value: Array of private link resources. - :vartype value: list[~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateLinkResource] - """ - - _attribute_map = { - "value": {"key": "value", "type": "[MHSMPrivateLinkResource]"}, - } - - def __init__(self, *, value: Optional[List["_models.MHSMPrivateLinkResource"]] = None, **kwargs: Any) -> None: - """ - :keyword value: Array of private link resources. - :paramtype value: list[~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateLinkResource] - """ - super().__init__(**kwargs) - self.value = value - - -class MHSMPrivateLinkServiceConnectionState(_serialization.Model): - """An object that represents the approval state of the private link connection. - - :ivar status: Indicates whether the connection has been approved, rejected or removed by the - key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :vartype status: str or - ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointServiceConnectionStatus - :ivar description: The reason for approval or rejection. - :vartype description: str - :ivar actions_required: A message indicating if changes on the service provider require any - updates on the consumer. "None" - :vartype actions_required: str or ~azure.mgmt.keyvault.v2022_07_01.models.ActionsRequired - """ - - _attribute_map = { - "status": {"key": "status", "type": "str"}, - "description": {"key": "description", "type": "str"}, - "actions_required": {"key": "actionsRequired", "type": "str"}, - } - - def __init__( - self, - *, - status: Optional[Union[str, "_models.PrivateEndpointServiceConnectionStatus"]] = None, - description: Optional[str] = None, - actions_required: Optional[Union[str, "_models.ActionsRequired"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword status: Indicates whether the connection has been approved, rejected or removed by the - key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :paramtype status: str or - ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointServiceConnectionStatus - :keyword description: The reason for approval or rejection. - :paramtype description: str - :keyword actions_required: A message indicating if changes on the service provider require any - updates on the consumer. "None" - :paramtype actions_required: str or ~azure.mgmt.keyvault.v2022_07_01.models.ActionsRequired - """ - super().__init__(**kwargs) - self.status = status - self.description = description - self.actions_required = actions_required - - -class MHSMVirtualNetworkRule(_serialization.Model): - """A rule governing the accessibility of a managed hsm pool from a specific virtual network. - - All required parameters must be populated in order to send to server. - - :ivar id: Full resource id of a vnet subnet, such as - '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. - Required. - :vartype id: str - """ - - _validation = { - "id": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - } - - def __init__(self, *, id: str, **kwargs: Any) -> None: # pylint: disable=redefined-builtin - """ - :keyword id: Full resource id of a vnet subnet, such as - '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. # pylint: disable=line-too-long - Required. - :paramtype id: str - """ - super().__init__(**kwargs) - self.id = id - - -class NetworkRuleSet(_serialization.Model): - """A set of rules governing the network accessibility of a vault. - - :ivar bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or - 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and - "None". - :vartype bypass: str or ~azure.mgmt.keyvault.v2022_07_01.models.NetworkRuleBypassOptions - :ivar default_action: The default action when no rule from ipRules and from virtualNetworkRules - match. This is only used after the bypass property has been evaluated. Known values are: - "Allow" and "Deny". - :vartype default_action: str or ~azure.mgmt.keyvault.v2022_07_01.models.NetworkRuleAction - :ivar ip_rules: The list of IP address rules. - :vartype ip_rules: list[~azure.mgmt.keyvault.v2022_07_01.models.IPRule] - :ivar virtual_network_rules: The list of virtual network rules. - :vartype virtual_network_rules: - list[~azure.mgmt.keyvault.v2022_07_01.models.VirtualNetworkRule] - """ - - _attribute_map = { - "bypass": {"key": "bypass", "type": "str"}, - "default_action": {"key": "defaultAction", "type": "str"}, - "ip_rules": {"key": "ipRules", "type": "[IPRule]"}, - "virtual_network_rules": {"key": "virtualNetworkRules", "type": "[VirtualNetworkRule]"}, - } - - def __init__( - self, - *, - bypass: Optional[Union[str, "_models.NetworkRuleBypassOptions"]] = None, - default_action: Optional[Union[str, "_models.NetworkRuleAction"]] = None, - ip_rules: Optional[List["_models.IPRule"]] = None, - virtual_network_rules: Optional[List["_models.VirtualNetworkRule"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or - 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and - "None". - :paramtype bypass: str or ~azure.mgmt.keyvault.v2022_07_01.models.NetworkRuleBypassOptions - :keyword default_action: The default action when no rule from ipRules and from - virtualNetworkRules match. This is only used after the bypass property has been evaluated. - Known values are: "Allow" and "Deny". - :paramtype default_action: str or ~azure.mgmt.keyvault.v2022_07_01.models.NetworkRuleAction - :keyword ip_rules: The list of IP address rules. - :paramtype ip_rules: list[~azure.mgmt.keyvault.v2022_07_01.models.IPRule] - :keyword virtual_network_rules: The list of virtual network rules. - :paramtype virtual_network_rules: - list[~azure.mgmt.keyvault.v2022_07_01.models.VirtualNetworkRule] - """ - super().__init__(**kwargs) - self.bypass = bypass - self.default_action = default_action - self.ip_rules = ip_rules - self.virtual_network_rules = virtual_network_rules - - -class Operation(_serialization.Model): - """Key Vault REST API operation definition. - - :ivar name: Operation name: {provider}/{resource}/{operation}. - :vartype name: str - :ivar display: Display metadata associated with the operation. - :vartype display: ~azure.mgmt.keyvault.v2022_07_01.models.OperationDisplay - :ivar origin: The origin of operations. - :vartype origin: str - :ivar is_data_action: Property to specify whether the action is a data action. - :vartype is_data_action: bool - :ivar service_specification: One property of operation, include metric specifications. - :vartype service_specification: ~azure.mgmt.keyvault.v2022_07_01.models.ServiceSpecification - """ - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "display": {"key": "display", "type": "OperationDisplay"}, - "origin": {"key": "origin", "type": "str"}, - "is_data_action": {"key": "isDataAction", "type": "bool"}, - "service_specification": {"key": "properties.serviceSpecification", "type": "ServiceSpecification"}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - display: Optional["_models.OperationDisplay"] = None, - origin: Optional[str] = None, - is_data_action: Optional[bool] = None, - service_specification: Optional["_models.ServiceSpecification"] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Operation name: {provider}/{resource}/{operation}. - :paramtype name: str - :keyword display: Display metadata associated with the operation. - :paramtype display: ~azure.mgmt.keyvault.v2022_07_01.models.OperationDisplay - :keyword origin: The origin of operations. - :paramtype origin: str - :keyword is_data_action: Property to specify whether the action is a data action. - :paramtype is_data_action: bool - :keyword service_specification: One property of operation, include metric specifications. - :paramtype service_specification: ~azure.mgmt.keyvault.v2022_07_01.models.ServiceSpecification - """ - super().__init__(**kwargs) - self.name = name - self.display = display - self.origin = origin - self.is_data_action = is_data_action - self.service_specification = service_specification - - -class OperationDisplay(_serialization.Model): - """Display metadata associated with the operation. - - :ivar provider: Service provider: Microsoft Key Vault. - :vartype provider: str - :ivar resource: Resource on which the operation is performed etc. - :vartype resource: str - :ivar operation: Type of operation: get, read, delete, etc. - :vartype operation: str - :ivar description: Description of operation. - :vartype description: str - """ - - _attribute_map = { - "provider": {"key": "provider", "type": "str"}, - "resource": {"key": "resource", "type": "str"}, - "operation": {"key": "operation", "type": "str"}, - "description": {"key": "description", "type": "str"}, - } - - def __init__( - self, - *, - provider: Optional[str] = None, - resource: Optional[str] = None, - operation: Optional[str] = None, - description: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword provider: Service provider: Microsoft Key Vault. - :paramtype provider: str - :keyword resource: Resource on which the operation is performed etc. - :paramtype resource: str - :keyword operation: Type of operation: get, read, delete, etc. - :paramtype operation: str - :keyword description: Description of operation. - :paramtype description: str - """ - super().__init__(**kwargs) - self.provider = provider - self.resource = resource - self.operation = operation - self.description = description - - -class OperationListResult(_serialization.Model): - """Result of the request to list Storage operations. It contains a list of operations and a URL - link to get the next set of results. - - :ivar value: List of Storage operations supported by the Storage resource provider. - :vartype value: list[~azure.mgmt.keyvault.v2022_07_01.models.Operation] - :ivar next_link: The URL to get the next set of operations. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Operation]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Operation"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: List of Storage operations supported by the Storage resource provider. - :paramtype value: list[~azure.mgmt.keyvault.v2022_07_01.models.Operation] - :keyword next_link: The URL to get the next set of operations. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class Permissions(_serialization.Model): - """Permissions the identity has for keys, secrets, certificates and storage. - - :ivar keys: Permissions to keys. - :vartype keys: list[str or ~azure.mgmt.keyvault.v2022_07_01.models.KeyPermissions] - :ivar secrets: Permissions to secrets. - :vartype secrets: list[str or ~azure.mgmt.keyvault.v2022_07_01.models.SecretPermissions] - :ivar certificates: Permissions to certificates. - :vartype certificates: list[str or - ~azure.mgmt.keyvault.v2022_07_01.models.CertificatePermissions] - :ivar storage: Permissions to storage accounts. - :vartype storage: list[str or ~azure.mgmt.keyvault.v2022_07_01.models.StoragePermissions] - """ - - _attribute_map = { - "keys": {"key": "keys", "type": "[str]"}, - "secrets": {"key": "secrets", "type": "[str]"}, - "certificates": {"key": "certificates", "type": "[str]"}, - "storage": {"key": "storage", "type": "[str]"}, - } - - def __init__( - self, - *, - keys: Optional[List[Union[str, "_models.KeyPermissions"]]] = None, - secrets: Optional[List[Union[str, "_models.SecretPermissions"]]] = None, - certificates: Optional[List[Union[str, "_models.CertificatePermissions"]]] = None, - storage: Optional[List[Union[str, "_models.StoragePermissions"]]] = None, - **kwargs: Any - ) -> None: - """ - :keyword keys: Permissions to keys. - :paramtype keys: list[str or ~azure.mgmt.keyvault.v2022_07_01.models.KeyPermissions] - :keyword secrets: Permissions to secrets. - :paramtype secrets: list[str or ~azure.mgmt.keyvault.v2022_07_01.models.SecretPermissions] - :keyword certificates: Permissions to certificates. - :paramtype certificates: list[str or - ~azure.mgmt.keyvault.v2022_07_01.models.CertificatePermissions] - :keyword storage: Permissions to storage accounts. - :paramtype storage: list[str or ~azure.mgmt.keyvault.v2022_07_01.models.StoragePermissions] - """ - super().__init__(**kwargs) - self.keys = keys - self.secrets = secrets - self.certificates = certificates - self.storage = storage - - -class PrivateEndpoint(_serialization.Model): - """Private endpoint object properties. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Full identifier of the private endpoint resource. - :vartype id: str - """ - - _validation = { - "id": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - } - - def __init__(self, **kwargs: Any) -> None: - """ """ - super().__init__(**kwargs) - self.id = None - - -class PrivateEndpointConnection(Resource): - """Private endpoint connection resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar etag: Modified whenever there is a change in the state of private endpoint connection. - :vartype etag: str - :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpoint - :ivar private_link_service_connection_state: Approval state of the private link connection. - :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2022_07_01.models.PrivateLinkServiceConnectionState - :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values - are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnectionProvisioningState - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "etag": {"key": "etag", "type": "str"}, - "private_endpoint": {"key": "properties.privateEndpoint", "type": "PrivateEndpoint"}, - "private_link_service_connection_state": { - "key": "properties.privateLinkServiceConnectionState", - "type": "PrivateLinkServiceConnectionState", - }, - "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - etag: Optional[str] = None, - private_endpoint: Optional["_models.PrivateEndpoint"] = None, - private_link_service_connection_state: Optional["_models.PrivateLinkServiceConnectionState"] = None, - provisioning_state: Optional[Union[str, "_models.PrivateEndpointConnectionProvisioningState"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword etag: Modified whenever there is a change in the state of private endpoint connection. - :paramtype etag: str - :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpoint - :keyword private_link_service_connection_state: Approval state of the private link connection. - :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2022_07_01.models.PrivateLinkServiceConnectionState - :keyword provisioning_state: Provisioning state of the private endpoint connection. Known - values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnectionProvisioningState - """ - super().__init__(**kwargs) - self.etag = etag - self.private_endpoint = private_endpoint - self.private_link_service_connection_state = private_link_service_connection_state - self.provisioning_state = provisioning_state - - -class PrivateEndpointConnectionItem(_serialization.Model): - """Private endpoint connection item. - - :ivar id: Id of private endpoint connection. - :vartype id: str - :ivar etag: Modified whenever there is a change in the state of private endpoint connection. - :vartype etag: str - :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpoint - :ivar private_link_service_connection_state: Approval state of the private link connection. - :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2022_07_01.models.PrivateLinkServiceConnectionState - :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values - are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnectionProvisioningState - """ - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "etag": {"key": "etag", "type": "str"}, - "private_endpoint": {"key": "properties.privateEndpoint", "type": "PrivateEndpoint"}, - "private_link_service_connection_state": { - "key": "properties.privateLinkServiceConnectionState", - "type": "PrivateLinkServiceConnectionState", - }, - "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, - } - - def __init__( - self, - *, - id: Optional[str] = None, # pylint: disable=redefined-builtin - etag: Optional[str] = None, - private_endpoint: Optional["_models.PrivateEndpoint"] = None, - private_link_service_connection_state: Optional["_models.PrivateLinkServiceConnectionState"] = None, - provisioning_state: Optional[Union[str, "_models.PrivateEndpointConnectionProvisioningState"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword id: Id of private endpoint connection. - :paramtype id: str - :keyword etag: Modified whenever there is a change in the state of private endpoint connection. - :paramtype etag: str - :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpoint - :keyword private_link_service_connection_state: Approval state of the private link connection. - :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2022_07_01.models.PrivateLinkServiceConnectionState - :keyword provisioning_state: Provisioning state of the private endpoint connection. Known - values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". - :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnectionProvisioningState - """ - super().__init__(**kwargs) - self.id = id - self.etag = etag - self.private_endpoint = private_endpoint - self.private_link_service_connection_state = private_link_service_connection_state - self.provisioning_state = provisioning_state - - -class PrivateEndpointConnectionListResult(_serialization.Model): - """List of private endpoint connections. - - :ivar value: The list of private endpoint connections. - :vartype value: list[~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection] - :ivar next_link: The URL to get the next set of private endpoint connections. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[PrivateEndpointConnection]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, - *, - value: Optional[List["_models.PrivateEndpointConnection"]] = None, - next_link: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword value: The list of private endpoint connections. - :paramtype value: list[~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection] - :keyword next_link: The URL to get the next set of private endpoint connections. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class PrivateLinkResource(Resource): - """A private link resource. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar group_id: Group identifier of private link resource. - :vartype group_id: str - :ivar required_members: Required member names of private link resource. - :vartype required_members: list[str] - :ivar required_zone_names: Required DNS zone names of the the private link resource. - :vartype required_zone_names: list[str] - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - "group_id": {"readonly": True}, - "required_members": {"readonly": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "group_id": {"key": "properties.groupId", "type": "str"}, - "required_members": {"key": "properties.requiredMembers", "type": "[str]"}, - "required_zone_names": {"key": "properties.requiredZoneNames", "type": "[str]"}, - } - - def __init__(self, *, required_zone_names: Optional[List[str]] = None, **kwargs: Any) -> None: - """ - :keyword required_zone_names: Required DNS zone names of the the private link resource. - :paramtype required_zone_names: list[str] - """ - super().__init__(**kwargs) - self.group_id = None - self.required_members = None - self.required_zone_names = required_zone_names - - -class PrivateLinkResourceListResult(_serialization.Model): - """A list of private link resources. - - :ivar value: Array of private link resources. - :vartype value: list[~azure.mgmt.keyvault.v2022_07_01.models.PrivateLinkResource] - """ - - _attribute_map = { - "value": {"key": "value", "type": "[PrivateLinkResource]"}, - } - - def __init__(self, *, value: Optional[List["_models.PrivateLinkResource"]] = None, **kwargs: Any) -> None: - """ - :keyword value: Array of private link resources. - :paramtype value: list[~azure.mgmt.keyvault.v2022_07_01.models.PrivateLinkResource] - """ - super().__init__(**kwargs) - self.value = value - - -class PrivateLinkServiceConnectionState(_serialization.Model): - """An object that represents the approval state of the private link connection. - - :ivar status: Indicates whether the connection has been approved, rejected or removed by the - key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :vartype status: str or - ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointServiceConnectionStatus - :ivar description: The reason for approval or rejection. - :vartype description: str - :ivar actions_required: A message indicating if changes on the service provider require any - updates on the consumer. "None" - :vartype actions_required: str or ~azure.mgmt.keyvault.v2022_07_01.models.ActionsRequired - """ - - _attribute_map = { - "status": {"key": "status", "type": "str"}, - "description": {"key": "description", "type": "str"}, - "actions_required": {"key": "actionsRequired", "type": "str"}, - } - - def __init__( - self, - *, - status: Optional[Union[str, "_models.PrivateEndpointServiceConnectionStatus"]] = None, - description: Optional[str] = None, - actions_required: Optional[Union[str, "_models.ActionsRequired"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword status: Indicates whether the connection has been approved, rejected or removed by the - key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :paramtype status: str or - ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointServiceConnectionStatus - :keyword description: The reason for approval or rejection. - :paramtype description: str - :keyword actions_required: A message indicating if changes on the service provider require any - updates on the consumer. "None" - :paramtype actions_required: str or ~azure.mgmt.keyvault.v2022_07_01.models.ActionsRequired - """ - super().__init__(**kwargs) - self.status = status - self.description = description - self.actions_required = actions_required - - -class ResourceListResult(_serialization.Model): - """List of vault resources. - - :ivar value: The list of vault resources. - :vartype value: list[~azure.mgmt.keyvault.v2022_07_01.models.Resource] - :ivar next_link: The URL to get the next set of vault resources. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Resource]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Resource"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of vault resources. - :paramtype value: list[~azure.mgmt.keyvault.v2022_07_01.models.Resource] - :keyword next_link: The URL to get the next set of vault resources. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class RotationPolicy(_serialization.Model): - """RotationPolicy. - - :ivar attributes: The attributes of key rotation policy. - :vartype attributes: ~azure.mgmt.keyvault.v2022_07_01.models.KeyRotationPolicyAttributes - :ivar lifetime_actions: The lifetimeActions for key rotation action. - :vartype lifetime_actions: list[~azure.mgmt.keyvault.v2022_07_01.models.LifetimeAction] - """ - - _attribute_map = { - "attributes": {"key": "attributes", "type": "KeyRotationPolicyAttributes"}, - "lifetime_actions": {"key": "lifetimeActions", "type": "[LifetimeAction]"}, - } - - def __init__( - self, - *, - attributes: Optional["_models.KeyRotationPolicyAttributes"] = None, - lifetime_actions: Optional[List["_models.LifetimeAction"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword attributes: The attributes of key rotation policy. - :paramtype attributes: ~azure.mgmt.keyvault.v2022_07_01.models.KeyRotationPolicyAttributes - :keyword lifetime_actions: The lifetimeActions for key rotation action. - :paramtype lifetime_actions: list[~azure.mgmt.keyvault.v2022_07_01.models.LifetimeAction] - """ - super().__init__(**kwargs) - self.attributes = attributes - self.lifetime_actions = lifetime_actions - - -class Secret(Resource): - """Resource information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar properties: Properties of the secret. Required. - :vartype properties: ~azure.mgmt.keyvault.v2022_07_01.models.SecretProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "tags": {"readonly": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "SecretProperties"}, - } - - def __init__(self, *, properties: "_models.SecretProperties", **kwargs: Any) -> None: - """ - :keyword properties: Properties of the secret. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2022_07_01.models.SecretProperties - """ - super().__init__(**kwargs) - self.properties = properties - - -class SecretAttributes(Attributes): - """The secret management attributes. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar enabled: Determines whether the object is enabled. - :vartype enabled: bool - :ivar not_before: Not before date in seconds since 1970-01-01T00:00:00Z. - :vartype not_before: ~datetime.datetime - :ivar expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :vartype expires: ~datetime.datetime - :ivar created: Creation time in seconds since 1970-01-01T00:00:00Z. - :vartype created: ~datetime.datetime - :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: ~datetime.datetime - """ - - -class SecretCreateOrUpdateParameters(_serialization.Model): - """Parameters for creating or updating a secret. - - All required parameters must be populated in order to send to server. - - :ivar tags: The tags that will be assigned to the secret. - :vartype tags: dict[str, str] - :ivar properties: Properties of the secret. Required. - :vartype properties: ~azure.mgmt.keyvault.v2022_07_01.models.SecretProperties - """ - - _validation = { - "properties": {"required": True}, - } - - _attribute_map = { - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "SecretProperties"}, - } - - def __init__( - self, *, properties: "_models.SecretProperties", tags: Optional[Dict[str, str]] = None, **kwargs: Any - ) -> None: - """ - :keyword tags: The tags that will be assigned to the secret. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the secret. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2022_07_01.models.SecretProperties - """ - super().__init__(**kwargs) - self.tags = tags - self.properties = properties - - -class SecretListResult(_serialization.Model): - """List of secrets. - - :ivar value: The list of secrets. - :vartype value: list[~azure.mgmt.keyvault.v2022_07_01.models.Secret] - :ivar next_link: The URL to get the next set of secrets. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Secret]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Secret"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of secrets. - :paramtype value: list[~azure.mgmt.keyvault.v2022_07_01.models.Secret] - :keyword next_link: The URL to get the next set of secrets. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class SecretPatchParameters(_serialization.Model): - """Parameters for patching a secret. - - :ivar tags: The tags that will be assigned to the secret. - :vartype tags: dict[str, str] - :ivar properties: Properties of the secret. - :vartype properties: ~azure.mgmt.keyvault.v2022_07_01.models.SecretPatchProperties - """ - - _attribute_map = { - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "SecretPatchProperties"}, - } - - def __init__( - self, - *, - tags: Optional[Dict[str, str]] = None, - properties: Optional["_models.SecretPatchProperties"] = None, - **kwargs: Any - ) -> None: - """ - :keyword tags: The tags that will be assigned to the secret. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the secret. - :paramtype properties: ~azure.mgmt.keyvault.v2022_07_01.models.SecretPatchProperties - """ - super().__init__(**kwargs) - self.tags = tags - self.properties = properties - - -class SecretPatchProperties(_serialization.Model): - """Properties of the secret. - - :ivar value: The value of the secret. - :vartype value: str - :ivar content_type: The content type of the secret. - :vartype content_type: str - :ivar attributes: The attributes of the secret. - :vartype attributes: ~azure.mgmt.keyvault.v2022_07_01.models.SecretAttributes - """ - - _attribute_map = { - "value": {"key": "value", "type": "str"}, - "content_type": {"key": "contentType", "type": "str"}, - "attributes": {"key": "attributes", "type": "SecretAttributes"}, - } - - def __init__( - self, - *, - value: Optional[str] = None, - content_type: Optional[str] = None, - attributes: Optional["_models.SecretAttributes"] = None, - **kwargs: Any - ) -> None: - """ - :keyword value: The value of the secret. - :paramtype value: str - :keyword content_type: The content type of the secret. - :paramtype content_type: str - :keyword attributes: The attributes of the secret. - :paramtype attributes: ~azure.mgmt.keyvault.v2022_07_01.models.SecretAttributes - """ - super().__init__(**kwargs) - self.value = value - self.content_type = content_type - self.attributes = attributes - - -class SecretProperties(_serialization.Model): - """Properties of the secret. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar value: The value of the secret. NOTE: 'value' will never be returned from the service, as - APIs using this model are is intended for internal use in ARM deployments. Users should use the - data-plane REST service for interaction with vault secrets. - :vartype value: str - :ivar content_type: The content type of the secret. - :vartype content_type: str - :ivar attributes: The attributes of the secret. - :vartype attributes: ~azure.mgmt.keyvault.v2022_07_01.models.SecretAttributes - :ivar secret_uri: The URI to retrieve the current version of the secret. - :vartype secret_uri: str - :ivar secret_uri_with_version: The URI to retrieve the specific version of the secret. - :vartype secret_uri_with_version: str - """ - - _validation = { - "secret_uri": {"readonly": True}, - "secret_uri_with_version": {"readonly": True}, - } - - _attribute_map = { - "value": {"key": "value", "type": "str"}, - "content_type": {"key": "contentType", "type": "str"}, - "attributes": {"key": "attributes", "type": "SecretAttributes"}, - "secret_uri": {"key": "secretUri", "type": "str"}, - "secret_uri_with_version": {"key": "secretUriWithVersion", "type": "str"}, - } - - def __init__( - self, - *, - value: Optional[str] = None, - content_type: Optional[str] = None, - attributes: Optional["_models.SecretAttributes"] = None, - **kwargs: Any - ) -> None: - """ - :keyword value: The value of the secret. NOTE: 'value' will never be returned from the service, - as APIs using this model are is intended for internal use in ARM deployments. Users should use - the data-plane REST service for interaction with vault secrets. - :paramtype value: str - :keyword content_type: The content type of the secret. - :paramtype content_type: str - :keyword attributes: The attributes of the secret. - :paramtype attributes: ~azure.mgmt.keyvault.v2022_07_01.models.SecretAttributes - """ - super().__init__(**kwargs) - self.value = value - self.content_type = content_type - self.attributes = attributes - self.secret_uri = None - self.secret_uri_with_version = None - - -class ServiceSpecification(_serialization.Model): - """One property of operation, include log specifications. - - :ivar log_specifications: Log specifications of operation. - :vartype log_specifications: list[~azure.mgmt.keyvault.v2022_07_01.models.LogSpecification] - :ivar metric_specifications: Metric specifications of operation. - :vartype metric_specifications: - list[~azure.mgmt.keyvault.v2022_07_01.models.MetricSpecification] - """ - - _attribute_map = { - "log_specifications": {"key": "logSpecifications", "type": "[LogSpecification]"}, - "metric_specifications": {"key": "metricSpecifications", "type": "[MetricSpecification]"}, - } - - def __init__( - self, - *, - log_specifications: Optional[List["_models.LogSpecification"]] = None, - metric_specifications: Optional[List["_models.MetricSpecification"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword log_specifications: Log specifications of operation. - :paramtype log_specifications: list[~azure.mgmt.keyvault.v2022_07_01.models.LogSpecification] - :keyword metric_specifications: Metric specifications of operation. - :paramtype metric_specifications: - list[~azure.mgmt.keyvault.v2022_07_01.models.MetricSpecification] - """ - super().__init__(**kwargs) - self.log_specifications = log_specifications - self.metric_specifications = metric_specifications - - -class Sku(_serialization.Model): - """SKU details. - - All required parameters must be populated in order to send to server. - - :ivar family: SKU family name. "A" - :vartype family: str or ~azure.mgmt.keyvault.v2022_07_01.models.SkuFamily - :ivar name: SKU name to specify whether the key vault is a standard vault or a premium vault. - Required. Known values are: "standard" and "premium". - :vartype name: str or ~azure.mgmt.keyvault.v2022_07_01.models.SkuName - """ - - _validation = { - "family": {"required": True}, - "name": {"required": True}, - } - - _attribute_map = { - "family": {"key": "family", "type": "str"}, - "name": {"key": "name", "type": "str"}, - } - - def __init__( - self, *, family: Union[str, "_models.SkuFamily"] = "A", name: Union[str, "_models.SkuName"], **kwargs: Any - ) -> None: - """ - :keyword family: SKU family name. "A" - :paramtype family: str or ~azure.mgmt.keyvault.v2022_07_01.models.SkuFamily - :keyword name: SKU name to specify whether the key vault is a standard vault or a premium - vault. Required. Known values are: "standard" and "premium". - :paramtype name: str or ~azure.mgmt.keyvault.v2022_07_01.models.SkuName - """ - super().__init__(**kwargs) - self.family = family - self.name = name - - -class SystemData(_serialization.Model): - """Metadata pertaining to creation and last modification of the key vault resource. - - :ivar created_by: The identity that created the key vault resource. - :vartype created_by: str - :ivar created_by_type: The type of identity that created the key vault resource. Known values - are: "User", "Application", "ManagedIdentity", and "Key". - :vartype created_by_type: str or ~azure.mgmt.keyvault.v2022_07_01.models.IdentityType - :ivar created_at: The timestamp of the key vault resource creation (UTC). - :vartype created_at: ~datetime.datetime - :ivar last_modified_by: The identity that last modified the key vault resource. - :vartype last_modified_by: str - :ivar last_modified_by_type: The type of identity that last modified the key vault resource. - Known values are: "User", "Application", "ManagedIdentity", and "Key". - :vartype last_modified_by_type: str or ~azure.mgmt.keyvault.v2022_07_01.models.IdentityType - :ivar last_modified_at: The timestamp of the key vault resource last modification (UTC). - :vartype last_modified_at: ~datetime.datetime - """ - - _attribute_map = { - "created_by": {"key": "createdBy", "type": "str"}, - "created_by_type": {"key": "createdByType", "type": "str"}, - "created_at": {"key": "createdAt", "type": "iso-8601"}, - "last_modified_by": {"key": "lastModifiedBy", "type": "str"}, - "last_modified_by_type": {"key": "lastModifiedByType", "type": "str"}, - "last_modified_at": {"key": "lastModifiedAt", "type": "iso-8601"}, - } - - def __init__( - self, - *, - created_by: Optional[str] = None, - created_by_type: Optional[Union[str, "_models.IdentityType"]] = None, - created_at: Optional[datetime.datetime] = None, - last_modified_by: Optional[str] = None, - last_modified_by_type: Optional[Union[str, "_models.IdentityType"]] = None, - last_modified_at: Optional[datetime.datetime] = None, - **kwargs: Any - ) -> None: - """ - :keyword created_by: The identity that created the key vault resource. - :paramtype created_by: str - :keyword created_by_type: The type of identity that created the key vault resource. Known - values are: "User", "Application", "ManagedIdentity", and "Key". - :paramtype created_by_type: str or ~azure.mgmt.keyvault.v2022_07_01.models.IdentityType - :keyword created_at: The timestamp of the key vault resource creation (UTC). - :paramtype created_at: ~datetime.datetime - :keyword last_modified_by: The identity that last modified the key vault resource. - :paramtype last_modified_by: str - :keyword last_modified_by_type: The type of identity that last modified the key vault resource. - Known values are: "User", "Application", "ManagedIdentity", and "Key". - :paramtype last_modified_by_type: str or ~azure.mgmt.keyvault.v2022_07_01.models.IdentityType - :keyword last_modified_at: The timestamp of the key vault resource last modification (UTC). - :paramtype last_modified_at: ~datetime.datetime - """ - super().__init__(**kwargs) - self.created_by = created_by - self.created_by_type = created_by_type - self.created_at = created_at - self.last_modified_by = last_modified_by - self.last_modified_by_type = last_modified_by_type - self.last_modified_at = last_modified_at - - -class Trigger(_serialization.Model): - """Trigger. - - :ivar time_after_create: The time duration after key creation to rotate the key. It only - applies to rotate. It will be in ISO 8601 duration format. Eg: 'P90D', 'P1Y'. - :vartype time_after_create: str - :ivar time_before_expiry: The time duration before key expiring to rotate or notify. It will be - in ISO 8601 duration format. Eg: 'P90D', 'P1Y'. - :vartype time_before_expiry: str - """ - - _attribute_map = { - "time_after_create": {"key": "timeAfterCreate", "type": "str"}, - "time_before_expiry": {"key": "timeBeforeExpiry", "type": "str"}, - } - - def __init__( - self, *, time_after_create: Optional[str] = None, time_before_expiry: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword time_after_create: The time duration after key creation to rotate the key. It only - applies to rotate. It will be in ISO 8601 duration format. Eg: 'P90D', 'P1Y'. - :paramtype time_after_create: str - :keyword time_before_expiry: The time duration before key expiring to rotate or notify. It will - be in ISO 8601 duration format. Eg: 'P90D', 'P1Y'. - :paramtype time_before_expiry: str - """ - super().__init__(**kwargs) - self.time_after_create = time_after_create - self.time_before_expiry = time_before_expiry - - -class Vault(_serialization.Model): - """Resource information with extended details. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar id: Fully qualified identifier of the key vault resource. - :vartype id: str - :ivar name: Name of the key vault resource. - :vartype name: str - :ivar type: Resource type of the key vault resource. - :vartype type: str - :ivar location: Azure location of the key vault resource. - :vartype location: str - :ivar tags: Tags assigned to the key vault resource. - :vartype tags: dict[str, str] - :ivar system_data: System metadata for the key vault. - :vartype system_data: ~azure.mgmt.keyvault.v2022_07_01.models.SystemData - :ivar properties: Properties of the vault. Required. - :vartype properties: ~azure.mgmt.keyvault.v2022_07_01.models.VaultProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "system_data": {"readonly": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "system_data": {"key": "systemData", "type": "SystemData"}, - "properties": {"key": "properties", "type": "VaultProperties"}, - } - - def __init__( - self, - *, - properties: "_models.VaultProperties", - location: Optional[str] = None, - tags: Optional[Dict[str, str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: Azure location of the key vault resource. - :paramtype location: str - :keyword tags: Tags assigned to the key vault resource. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the vault. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2022_07_01.models.VaultProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = location - self.tags = tags - self.system_data = None - self.properties = properties - - -class VaultAccessPolicyParameters(_serialization.Model): - """Parameters for updating the access policy in a vault. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar id: The resource id of the access policy. - :vartype id: str - :ivar name: The resource name of the access policy. - :vartype name: str - :ivar type: The resource name of the access policy. - :vartype type: str - :ivar location: The resource type of the access policy. - :vartype location: str - :ivar properties: Properties of the access policy. Required. - :vartype properties: ~azure.mgmt.keyvault.v2022_07_01.models.VaultAccessPolicyProperties - """ - - _validation = { - "id": {"readonly": True}, - "name": {"readonly": True}, - "type": {"readonly": True}, - "location": {"readonly": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "location": {"key": "location", "type": "str"}, - "properties": {"key": "properties", "type": "VaultAccessPolicyProperties"}, - } - - def __init__(self, *, properties: "_models.VaultAccessPolicyProperties", **kwargs: Any) -> None: - """ - :keyword properties: Properties of the access policy. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2022_07_01.models.VaultAccessPolicyProperties - """ - super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.location = None - self.properties = properties - - -class VaultAccessPolicyProperties(_serialization.Model): - """Properties of the vault access policy. - - All required parameters must be populated in order to send to server. - - :ivar access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. Required. - :vartype access_policies: list[~azure.mgmt.keyvault.v2022_07_01.models.AccessPolicyEntry] - """ - - _validation = { - "access_policies": {"required": True}, - } - - _attribute_map = { - "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, - } - - def __init__(self, *, access_policies: List["_models.AccessPolicyEntry"], **kwargs: Any) -> None: - """ - :keyword access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. Required. - :paramtype access_policies: list[~azure.mgmt.keyvault.v2022_07_01.models.AccessPolicyEntry] - """ - super().__init__(**kwargs) - self.access_policies = access_policies - - -class VaultCheckNameAvailabilityParameters(_serialization.Model): - """The parameters used to check the availability of the vault name. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar name: The vault name. Required. - :vartype name: str - :ivar type: The type of resource, Microsoft.KeyVault/vaults. Required. Default value is - "Microsoft.KeyVault/vaults". - :vartype type: str - """ - - _validation = { - "name": {"required": True}, - "type": {"required": True, "constant": True}, - } - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "type": {"key": "type", "type": "str"}, - } - - type = "Microsoft.KeyVault/vaults" - - def __init__(self, *, name: str, **kwargs: Any) -> None: - """ - :keyword name: The vault name. Required. - :paramtype name: str - """ - super().__init__(**kwargs) - self.name = name - - -class VaultCreateOrUpdateParameters(_serialization.Model): - """Parameters for creating or updating a vault. - - All required parameters must be populated in order to send to server. - - :ivar location: The supported Azure location where the key vault should be created. Required. - :vartype location: str - :ivar tags: The tags that will be assigned to the key vault. - :vartype tags: dict[str, str] - :ivar properties: Properties of the vault. Required. - :vartype properties: ~azure.mgmt.keyvault.v2022_07_01.models.VaultProperties - """ - - _validation = { - "location": {"required": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "location": {"key": "location", "type": "str"}, - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "VaultProperties"}, - } - - def __init__( - self, - *, - location: str, - properties: "_models.VaultProperties", - tags: Optional[Dict[str, str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword location: The supported Azure location where the key vault should be created. - Required. - :paramtype location: str - :keyword tags: The tags that will be assigned to the key vault. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the vault. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2022_07_01.models.VaultProperties - """ - super().__init__(**kwargs) - self.location = location - self.tags = tags - self.properties = properties - - -class VaultListResult(_serialization.Model): - """List of vaults. - - :ivar value: The list of vaults. - :vartype value: list[~azure.mgmt.keyvault.v2022_07_01.models.Vault] - :ivar next_link: The URL to get the next set of vaults. - :vartype next_link: str - """ - - _attribute_map = { - "value": {"key": "value", "type": "[Vault]"}, - "next_link": {"key": "nextLink", "type": "str"}, - } - - def __init__( - self, *, value: Optional[List["_models.Vault"]] = None, next_link: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword value: The list of vaults. - :paramtype value: list[~azure.mgmt.keyvault.v2022_07_01.models.Vault] - :keyword next_link: The URL to get the next set of vaults. - :paramtype next_link: str - """ - super().__init__(**kwargs) - self.value = value - self.next_link = next_link - - -class VaultPatchParameters(_serialization.Model): - """Parameters for creating or updating a vault. - - :ivar tags: The tags that will be assigned to the key vault. - :vartype tags: dict[str, str] - :ivar properties: Properties of the vault. - :vartype properties: ~azure.mgmt.keyvault.v2022_07_01.models.VaultPatchProperties - """ - - _attribute_map = { - "tags": {"key": "tags", "type": "{str}"}, - "properties": {"key": "properties", "type": "VaultPatchProperties"}, - } - - def __init__( - self, - *, - tags: Optional[Dict[str, str]] = None, - properties: Optional["_models.VaultPatchProperties"] = None, - **kwargs: Any - ) -> None: - """ - :keyword tags: The tags that will be assigned to the key vault. - :paramtype tags: dict[str, str] - :keyword properties: Properties of the vault. - :paramtype properties: ~azure.mgmt.keyvault.v2022_07_01.models.VaultPatchProperties - """ - super().__init__(**kwargs) - self.tags = tags - self.properties = properties - - -class VaultPatchProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Properties of the vault. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. - :vartype tenant_id: str - :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2022_07_01.models.Sku - :ivar access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. - :vartype access_policies: list[~azure.mgmt.keyvault.v2022_07_01.models.AccessPolicyEntry] - :ivar enabled_for_deployment: Property to specify whether Azure Virtual Machines are permitted - to retrieve certificates stored as secrets from the key vault. - :vartype enabled_for_deployment: bool - :ivar enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :vartype enabled_for_disk_encryption: bool - :ivar enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :vartype enabled_for_template_deployment: bool - :ivar enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. Once set to true, it cannot be reverted to false. - :vartype enable_soft_delete: bool - :ivar enable_rbac_authorization: Property that controls how data actions are authorized. When - true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored. When false, - the key vault will use the access policies specified in vault properties, and any policy stored - on Azure Resource Manager will be ignored. If null or not specified, the value of this property - will not change. - :vartype enable_rbac_authorization: bool - :ivar soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and <=90. - :vartype soft_delete_retention_in_days: int - :ivar create_mode: The vault's create mode to indicate whether the vault need to be recovered - or not. Known values are: "recover" and "default". - :vartype create_mode: str or ~azure.mgmt.keyvault.v2022_07_01.models.CreateMode - :ivar enable_purge_protection: Property specifying whether protection against purge is enabled - for this vault. Setting this property to true activates protection against purge for this vault - and its content - only the Key Vault service may initiate a hard, irrecoverable deletion. The - setting is effective only if soft delete is also enabled. Enabling this functionality is - irreversible - that is, the property does not accept false as its value. - :vartype enable_purge_protection: bool - :ivar network_acls: A collection of rules governing the accessibility of the vault from - specific network locations. - :vartype network_acls: ~azure.mgmt.keyvault.v2022_07_01.models.NetworkRuleSet - :ivar public_network_access: Property to specify whether the vault will accept traffic from - public internet. If set to 'disabled' all traffic except private endpoint traffic and that that - originates from trusted services will be blocked. This will override the set firewall rules, - meaning that even if the firewall rules are present we will not honor the rules. - :vartype public_network_access: str - """ - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "sku": {"key": "sku", "type": "Sku"}, - "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, - "enabled_for_deployment": {"key": "enabledForDeployment", "type": "bool"}, - "enabled_for_disk_encryption": {"key": "enabledForDiskEncryption", "type": "bool"}, - "enabled_for_template_deployment": {"key": "enabledForTemplateDeployment", "type": "bool"}, - "enable_soft_delete": {"key": "enableSoftDelete", "type": "bool"}, - "enable_rbac_authorization": {"key": "enableRbacAuthorization", "type": "bool"}, - "soft_delete_retention_in_days": {"key": "softDeleteRetentionInDays", "type": "int"}, - "create_mode": {"key": "createMode", "type": "str"}, - "enable_purge_protection": {"key": "enablePurgeProtection", "type": "bool"}, - "network_acls": {"key": "networkAcls", "type": "NetworkRuleSet"}, - "public_network_access": {"key": "publicNetworkAccess", "type": "str"}, - } - - def __init__( - self, - *, - tenant_id: Optional[str] = None, - sku: Optional["_models.Sku"] = None, - access_policies: Optional[List["_models.AccessPolicyEntry"]] = None, - enabled_for_deployment: Optional[bool] = None, - enabled_for_disk_encryption: Optional[bool] = None, - enabled_for_template_deployment: Optional[bool] = None, - enable_soft_delete: Optional[bool] = None, - enable_rbac_authorization: Optional[bool] = None, - soft_delete_retention_in_days: Optional[int] = None, - create_mode: Optional[Union[str, "_models.CreateMode"]] = None, - enable_purge_protection: Optional[bool] = None, - network_acls: Optional["_models.NetworkRuleSet"] = None, - public_network_access: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. - :paramtype tenant_id: str - :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2022_07_01.models.Sku - :keyword access_policies: An array of 0 to 16 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. - :paramtype access_policies: list[~azure.mgmt.keyvault.v2022_07_01.models.AccessPolicyEntry] - :keyword enabled_for_deployment: Property to specify whether Azure Virtual Machines are - permitted to retrieve certificates stored as secrets from the key vault. - :paramtype enabled_for_deployment: bool - :keyword enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :paramtype enabled_for_disk_encryption: bool - :keyword enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :paramtype enabled_for_template_deployment: bool - :keyword enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. Once set to true, it cannot be reverted to false. - :paramtype enable_soft_delete: bool - :keyword enable_rbac_authorization: Property that controls how data actions are authorized. - When true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored. When false, - the key vault will use the access policies specified in vault properties, and any policy stored - on Azure Resource Manager will be ignored. If null or not specified, the value of this property - will not change. - :paramtype enable_rbac_authorization: bool - :keyword soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and - <=90. - :paramtype soft_delete_retention_in_days: int - :keyword create_mode: The vault's create mode to indicate whether the vault need to be - recovered or not. Known values are: "recover" and "default". - :paramtype create_mode: str or ~azure.mgmt.keyvault.v2022_07_01.models.CreateMode - :keyword enable_purge_protection: Property specifying whether protection against purge is - enabled for this vault. Setting this property to true activates protection against purge for - this vault and its content - only the Key Vault service may initiate a hard, irrecoverable - deletion. The setting is effective only if soft delete is also enabled. Enabling this - functionality is irreversible - that is, the property does not accept false as its value. - :paramtype enable_purge_protection: bool - :keyword network_acls: A collection of rules governing the accessibility of the vault from - specific network locations. - :paramtype network_acls: ~azure.mgmt.keyvault.v2022_07_01.models.NetworkRuleSet - :keyword public_network_access: Property to specify whether the vault will accept traffic from - public internet. If set to 'disabled' all traffic except private endpoint traffic and that that - originates from trusted services will be blocked. This will override the set firewall rules, - meaning that even if the firewall rules are present we will not honor the rules. - :paramtype public_network_access: str - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.sku = sku - self.access_policies = access_policies - self.enabled_for_deployment = enabled_for_deployment - self.enabled_for_disk_encryption = enabled_for_disk_encryption - self.enabled_for_template_deployment = enabled_for_template_deployment - self.enable_soft_delete = enable_soft_delete - self.enable_rbac_authorization = enable_rbac_authorization - self.soft_delete_retention_in_days = soft_delete_retention_in_days - self.create_mode = create_mode - self.enable_purge_protection = enable_purge_protection - self.network_acls = network_acls - self.public_network_access = public_network_access - - -class VaultProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes - """Properties of the vault. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to server. - - :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :vartype tenant_id: str - :ivar sku: SKU details. Required. - :vartype sku: ~azure.mgmt.keyvault.v2022_07_01.models.Sku - :ivar access_policies: An array of 0 to 1024 identities that have access to the key vault. All - identities in the array must use the same tenant ID as the key vault's tenant ID. When - ``createMode`` is set to ``recover``\\ , access policies are not required. Otherwise, access - policies are required. - :vartype access_policies: list[~azure.mgmt.keyvault.v2022_07_01.models.AccessPolicyEntry] - :ivar vault_uri: The URI of the vault for performing operations on keys and secrets. - :vartype vault_uri: str - :ivar hsm_pool_resource_id: The resource id of HSM Pool. - :vartype hsm_pool_resource_id: str - :ivar enabled_for_deployment: Property to specify whether Azure Virtual Machines are permitted - to retrieve certificates stored as secrets from the key vault. - :vartype enabled_for_deployment: bool - :ivar enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :vartype enabled_for_disk_encryption: bool - :ivar enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :vartype enabled_for_template_deployment: bool - :ivar enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. If it's not set to any value(true or false) when creating new key - vault, it will be set to true by default. Once set to true, it cannot be reverted to false. - :vartype enable_soft_delete: bool - :ivar soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and <=90. - :vartype soft_delete_retention_in_days: int - :ivar enable_rbac_authorization: Property that controls how data actions are authorized. When - true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored. When false, - the key vault will use the access policies specified in vault properties, and any policy stored - on Azure Resource Manager will be ignored. If null or not specified, the vault is created with - the default value of false. Note that management actions are always authorized with RBAC. - :vartype enable_rbac_authorization: bool - :ivar create_mode: The vault's create mode to indicate whether the vault need to be recovered - or not. Known values are: "recover" and "default". - :vartype create_mode: str or ~azure.mgmt.keyvault.v2022_07_01.models.CreateMode - :ivar enable_purge_protection: Property specifying whether protection against purge is enabled - for this vault. Setting this property to true activates protection against purge for this vault - and its content - only the Key Vault service may initiate a hard, irrecoverable deletion. The - setting is effective only if soft delete is also enabled. Enabling this functionality is - irreversible - that is, the property does not accept false as its value. - :vartype enable_purge_protection: bool - :ivar network_acls: Rules governing the accessibility of the key vault from specific network - locations. - :vartype network_acls: ~azure.mgmt.keyvault.v2022_07_01.models.NetworkRuleSet - :ivar provisioning_state: Provisioning state of the vault. Known values are: "Succeeded" and - "RegisteringDns". - :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2022_07_01.models.VaultProvisioningState - :ivar private_endpoint_connections: List of private endpoint connections associated with the - key vault. - :vartype private_endpoint_connections: - list[~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnectionItem] - :ivar public_network_access: Property to specify whether the vault will accept traffic from - public internet. If set to 'disabled' all traffic except private endpoint traffic and that that - originates from trusted services will be blocked. This will override the set firewall rules, - meaning that even if the firewall rules are present we will not honor the rules. - :vartype public_network_access: str - """ - - _validation = { - "tenant_id": {"required": True}, - "sku": {"required": True}, - "hsm_pool_resource_id": {"readonly": True}, - "private_endpoint_connections": {"readonly": True}, - } - - _attribute_map = { - "tenant_id": {"key": "tenantId", "type": "str"}, - "sku": {"key": "sku", "type": "Sku"}, - "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, - "vault_uri": {"key": "vaultUri", "type": "str"}, - "hsm_pool_resource_id": {"key": "hsmPoolResourceId", "type": "str"}, - "enabled_for_deployment": {"key": "enabledForDeployment", "type": "bool"}, - "enabled_for_disk_encryption": {"key": "enabledForDiskEncryption", "type": "bool"}, - "enabled_for_template_deployment": {"key": "enabledForTemplateDeployment", "type": "bool"}, - "enable_soft_delete": {"key": "enableSoftDelete", "type": "bool"}, - "soft_delete_retention_in_days": {"key": "softDeleteRetentionInDays", "type": "int"}, - "enable_rbac_authorization": {"key": "enableRbacAuthorization", "type": "bool"}, - "create_mode": {"key": "createMode", "type": "str"}, - "enable_purge_protection": {"key": "enablePurgeProtection", "type": "bool"}, - "network_acls": {"key": "networkAcls", "type": "NetworkRuleSet"}, - "provisioning_state": {"key": "provisioningState", "type": "str"}, - "private_endpoint_connections": { - "key": "privateEndpointConnections", - "type": "[PrivateEndpointConnectionItem]", - }, - "public_network_access": {"key": "publicNetworkAccess", "type": "str"}, - } - - def __init__( - self, - *, - tenant_id: str, - sku: "_models.Sku", - access_policies: Optional[List["_models.AccessPolicyEntry"]] = None, - vault_uri: Optional[str] = None, - enabled_for_deployment: Optional[bool] = None, - enabled_for_disk_encryption: Optional[bool] = None, - enabled_for_template_deployment: Optional[bool] = None, - enable_soft_delete: bool = True, - soft_delete_retention_in_days: int = 90, - enable_rbac_authorization: bool = False, - create_mode: Optional[Union[str, "_models.CreateMode"]] = None, - enable_purge_protection: Optional[bool] = None, - network_acls: Optional["_models.NetworkRuleSet"] = None, - provisioning_state: Optional[Union[str, "_models.VaultProvisioningState"]] = None, - public_network_access: str = "enabled", - **kwargs: Any - ) -> None: - """ - :keyword tenant_id: The Azure Active Directory tenant ID that should be used for authenticating - requests to the key vault. Required. - :paramtype tenant_id: str - :keyword sku: SKU details. Required. - :paramtype sku: ~azure.mgmt.keyvault.v2022_07_01.models.Sku - :keyword access_policies: An array of 0 to 1024 identities that have access to the key vault. - All identities in the array must use the same tenant ID as the key vault's tenant ID. When - ``createMode`` is set to ``recover``\\ , access policies are not required. Otherwise, access - policies are required. - :paramtype access_policies: list[~azure.mgmt.keyvault.v2022_07_01.models.AccessPolicyEntry] - :keyword vault_uri: The URI of the vault for performing operations on keys and secrets. - :paramtype vault_uri: str - :keyword enabled_for_deployment: Property to specify whether Azure Virtual Machines are - permitted to retrieve certificates stored as secrets from the key vault. - :paramtype enabled_for_deployment: bool - :keyword enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is - permitted to retrieve secrets from the vault and unwrap keys. - :paramtype enabled_for_disk_encryption: bool - :keyword enabled_for_template_deployment: Property to specify whether Azure Resource Manager is - permitted to retrieve secrets from the key vault. - :paramtype enabled_for_template_deployment: bool - :keyword enable_soft_delete: Property to specify whether the 'soft delete' functionality is - enabled for this key vault. If it's not set to any value(true or false) when creating new key - vault, it will be set to true by default. Once set to true, it cannot be reverted to false. - :paramtype enable_soft_delete: bool - :keyword soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and - <=90. - :paramtype soft_delete_retention_in_days: int - :keyword enable_rbac_authorization: Property that controls how data actions are authorized. - When true, the key vault will use Role Based Access Control (RBAC) for authorization of data - actions, and the access policies specified in vault properties will be ignored. When false, - the key vault will use the access policies specified in vault properties, and any policy stored - on Azure Resource Manager will be ignored. If null or not specified, the vault is created with - the default value of false. Note that management actions are always authorized with RBAC. - :paramtype enable_rbac_authorization: bool - :keyword create_mode: The vault's create mode to indicate whether the vault need to be - recovered or not. Known values are: "recover" and "default". - :paramtype create_mode: str or ~azure.mgmt.keyvault.v2022_07_01.models.CreateMode - :keyword enable_purge_protection: Property specifying whether protection against purge is - enabled for this vault. Setting this property to true activates protection against purge for - this vault and its content - only the Key Vault service may initiate a hard, irrecoverable - deletion. The setting is effective only if soft delete is also enabled. Enabling this - functionality is irreversible - that is, the property does not accept false as its value. - :paramtype enable_purge_protection: bool - :keyword network_acls: Rules governing the accessibility of the key vault from specific network - locations. - :paramtype network_acls: ~azure.mgmt.keyvault.v2022_07_01.models.NetworkRuleSet - :keyword provisioning_state: Provisioning state of the vault. Known values are: "Succeeded" and - "RegisteringDns". - :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2022_07_01.models.VaultProvisioningState - :keyword public_network_access: Property to specify whether the vault will accept traffic from - public internet. If set to 'disabled' all traffic except private endpoint traffic and that that - originates from trusted services will be blocked. This will override the set firewall rules, - meaning that even if the firewall rules are present we will not honor the rules. - :paramtype public_network_access: str - """ - super().__init__(**kwargs) - self.tenant_id = tenant_id - self.sku = sku - self.access_policies = access_policies - self.vault_uri = vault_uri - self.hsm_pool_resource_id = None - self.enabled_for_deployment = enabled_for_deployment - self.enabled_for_disk_encryption = enabled_for_disk_encryption - self.enabled_for_template_deployment = enabled_for_template_deployment - self.enable_soft_delete = enable_soft_delete - self.soft_delete_retention_in_days = soft_delete_retention_in_days - self.enable_rbac_authorization = enable_rbac_authorization - self.create_mode = create_mode - self.enable_purge_protection = enable_purge_protection - self.network_acls = network_acls - self.provisioning_state = provisioning_state - self.private_endpoint_connections = None - self.public_network_access = public_network_access - - -class VirtualNetworkRule(_serialization.Model): - """A rule governing the accessibility of a vault from a specific virtual network. - - All required parameters must be populated in order to send to server. - - :ivar id: Full resource id of a vnet subnet, such as - '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. - Required. - :vartype id: str - :ivar ignore_missing_vnet_service_endpoint: Property to specify whether NRP will ignore the - check if parent subnet has serviceEndpoints configured. - :vartype ignore_missing_vnet_service_endpoint: bool - """ - - _validation = { - "id": {"required": True}, - } - - _attribute_map = { - "id": {"key": "id", "type": "str"}, - "ignore_missing_vnet_service_endpoint": {"key": "ignoreMissingVnetServiceEndpoint", "type": "bool"}, - } - - def __init__( - self, - *, - id: str, # pylint: disable=redefined-builtin - ignore_missing_vnet_service_endpoint: Optional[bool] = None, - **kwargs: Any - ) -> None: - """ - :keyword id: Full resource id of a vnet subnet, such as - '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. # pylint: disable=line-too-long - Required. - :paramtype id: str - :keyword ignore_missing_vnet_service_endpoint: Property to specify whether NRP will ignore the - check if parent subnet has serviceEndpoints configured. - :paramtype ignore_missing_vnet_service_endpoint: bool - """ - super().__init__(**kwargs) - self.id = id - self.ignore_missing_vnet_service_endpoint = ignore_missing_vnet_service_endpoint diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/models/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/models/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/models/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/__init__.py deleted file mode 100644 index 224be3f73e55..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/__init__.py +++ /dev/null @@ -1,35 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._keys_operations import KeysOperations -from ._vaults_operations import VaultsOperations -from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations -from ._private_link_resources_operations import PrivateLinkResourcesOperations -from ._managed_hsms_operations import ManagedHsmsOperations -from ._mhsm_private_endpoint_connections_operations import MHSMPrivateEndpointConnectionsOperations -from ._mhsm_private_link_resources_operations import MHSMPrivateLinkResourcesOperations -from ._operations import Operations -from ._secrets_operations import SecretsOperations - -from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "KeysOperations", - "VaultsOperations", - "PrivateEndpointConnectionsOperations", - "PrivateLinkResourcesOperations", - "ManagedHsmsOperations", - "MHSMPrivateEndpointConnectionsOperations", - "MHSMPrivateLinkResourcesOperations", - "Operations", - "SecretsOperations", -] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_managed_hsms_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_managed_hsms_operations.py deleted file mode 100644 index 86438a5dd1f8..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_managed_hsms_operations.py +++ /dev/null @@ -1,1393 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_or_update_request( - resource_group_name: str, name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_request(resource_group_name: str, name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request(resource_group_name: str, name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request(resource_group_name: str, name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_resource_group_request( - resource_group_name: str, subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_subscription_request( - subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_deleted_request(subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedManagedHSMs") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_deleted_request(name: str, location: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "name": _SERIALIZER.url("name", name, "str"), - "location": _SERIALIZER.url("location", location, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_purge_deleted_request(name: str, location: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge", - ) # pylint: disable=line-too-long - path_format_arguments = { - "name": _SERIALIZER.url("name", name, "str"), - "location": _SERIALIZER.url("location", location, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_check_mhsm_name_availability_request( # pylint: disable=name-too-long - subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkMhsmNameAvailability" - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -class ManagedHsmsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2022_07_01.KeyVaultManagementClient`'s - :attr:`managed_hsms` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - def _create_or_update_initial( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "ManagedHsm") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def begin_create_or_update( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Is either a ManagedHsm - type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm or IO[bytes] - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._create_or_update_initial( - resource_group_name=resource_group_name, - name=name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.ManagedHsm].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.ManagedHsm]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - def _update_initial( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "ManagedHsm") - - _request = build_update_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @overload - def begin_update( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_update( - self, - resource_group_name: str, - name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def begin_update( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> LROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Is either a ManagedHsm type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm or IO[bytes] - :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._update_initial( - resource_group_name=resource_group_name, - name=name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.ManagedHsm].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.ManagedHsm]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - def _delete_initial(self, resource_group_name: str, name: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_delete(self, resource_group_name: str, name: str, **kwargs: Any) -> LROPoller[None]: - """Deletes the specified managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: The name of the managed HSM Pool to delete. Required. - :type name: str - :return: An instance of LROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._delete_initial( - resource_group_name=resource_group_name, - name=name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def get(self, resource_group_name: str, name: str, **kwargs: Any) -> Optional[_models.ManagedHsm]: - """Gets the specified managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: The name of the managed HSM Pool. Required. - :type name: str - :return: ManagedHsm or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm or None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[Optional[_models.ManagedHsm]] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> Iterable["_models.ManagedHsm"]: - """The List operation gets information about the managed HSM Pools associated with the - subscription and within the specified resource group. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.ManagedHsm"]: - """The List operation gets information about the managed HSM Pools associated with the - subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedManagedHsm"]: - """The List operation gets information about the deleted managed HSMs associated with the - subscription. - - :return: An iterator like instance of either DeletedManagedHsm or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.DeletedManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.DeletedManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("DeletedManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def get_deleted(self, name: str, location: str, **kwargs: Any) -> _models.DeletedManagedHsm: - """Gets the specified deleted managed HSM. - - :param name: The name of the deleted managed HSM. Required. - :type name: str - :param location: The location of the deleted managed HSM. Required. - :type location: str - :return: DeletedManagedHsm or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.DeletedManagedHsm - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.DeletedManagedHsm] = kwargs.pop("cls", None) - - _request = build_get_deleted_request( - name=name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = self._deserialize("DeletedManagedHsm", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_purge_deleted_request( - name=name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_purge_deleted(self, name: str, location: str, **kwargs: Any) -> LROPoller[None]: - """Permanently deletes the specified managed HSM. - - :param name: The name of the soft-deleted managed HSM. Required. - :type name: str - :param location: The location of the soft-deleted managed HSM. Required. - :type location: str - :return: An instance of LROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._purge_deleted_initial( - name=name, - location=location, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @overload - def check_mhsm_name_availability( - self, - mhsm_name: _models.CheckMhsmNameAvailabilityParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.CheckMhsmNameAvailabilityResult: - """Checks that the managed hsm name is valid and is not already in use. - - :param mhsm_name: The name of the managed hsm. Required. - :type mhsm_name: ~azure.mgmt.keyvault.v2022_07_01.models.CheckMhsmNameAvailabilityParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckMhsmNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.CheckMhsmNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def check_mhsm_name_availability( - self, mhsm_name: IO[bytes], *, content_type: str = "application/json", **kwargs: Any - ) -> _models.CheckMhsmNameAvailabilityResult: - """Checks that the managed hsm name is valid and is not already in use. - - :param mhsm_name: The name of the managed hsm. Required. - :type mhsm_name: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckMhsmNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.CheckMhsmNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def check_mhsm_name_availability( - self, mhsm_name: Union[_models.CheckMhsmNameAvailabilityParameters, IO[bytes]], **kwargs: Any - ) -> _models.CheckMhsmNameAvailabilityResult: - """Checks that the managed hsm name is valid and is not already in use. - - :param mhsm_name: The name of the managed hsm. Is either a CheckMhsmNameAvailabilityParameters - type or a IO[bytes] type. Required. - :type mhsm_name: ~azure.mgmt.keyvault.v2022_07_01.models.CheckMhsmNameAvailabilityParameters or - IO[bytes] - :return: CheckMhsmNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.CheckMhsmNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.CheckMhsmNameAvailabilityResult] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(mhsm_name, (IOBase, bytes)): - _content = mhsm_name - else: - _json = self._serialize.body(mhsm_name, "CheckMhsmNameAvailabilityParameters") - - _request = build_check_mhsm_name_availability_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("CheckMhsmNameAvailabilityResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_mhsm_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_mhsm_private_endpoint_connections_operations.py deleted file mode 100644 index 8d36793e5eb8..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_mhsm_private_endpoint_connections_operations.py +++ /dev/null @@ -1,620 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_by_resource_request( - resource_group_name: str, name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request( - resource_group_name: str, name: str, private_endpoint_connection_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_put_request( - resource_group_name: str, name: str, private_endpoint_connection_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request( - resource_group_name: str, name: str, private_endpoint_connection_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -class MHSMPrivateEndpointConnectionsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2022_07_01.KeyVaultManagementClient`'s - :attr:`mhsm_private_endpoint_connections` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list_by_resource( - self, resource_group_name: str, name: str, **kwargs: Any - ) -> Iterable["_models.MHSMPrivateEndpointConnection"]: - """The List operation gets information about the private endpoint connections associated with the - managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :return: An iterator like instance of either MHSMPrivateEndpointConnection or the result of - cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("MHSMPrivateEndpointConnectionsListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def get( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Gets the specified private endpoint connection associated with the managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: _models.MHSMPrivateEndpointConnection, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def put( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - properties: Union[_models.MHSMPrivateEndpointConnection, IO[bytes]], - **kwargs: Any - ) -> _models.MHSMPrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Is either a - MHSMPrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection or - IO[bytes] - :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _json = self._serialize.body(properties, "MHSMPrivateEndpointConnection") - - _request = build_put_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Azure-AsyncOperation"] = self._deserialize( - "str", response.headers.get("Azure-AsyncOperation") - ) - - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - def _delete_initial( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_delete( - self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> LROPoller[_models.MHSMPrivateEndpointConnection]: - """Deletes the specified private endpoint connection associated with the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the managed hsm pool. Required. - :type private_endpoint_connection_name: str - :return: An instance of LROPoller that returns either MHSMPrivateEndpointConnection or the - result of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._delete_initial( - resource_group_name=resource_group_name, - name=name, - private_endpoint_connection_name=private_endpoint_connection_name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.MHSMPrivateEndpointConnection].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.MHSMPrivateEndpointConnection]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_mhsm_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_mhsm_private_link_resources_operations.py deleted file mode 100644 index 254741865519..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_mhsm_private_link_resources_operations.py +++ /dev/null @@ -1,146 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_by_mhsm_resource_request( - resource_group_name: str, name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateLinkResources", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "name": _SERIALIZER.url("name", name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class MHSMPrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2022_07_01.KeyVaultManagementClient`'s - :attr:`mhsm_private_link_resources` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list_by_mhsm_resource( - self, resource_group_name: str, name: str, **kwargs: Any - ) -> _models.MHSMPrivateLinkResourceListResult: - """Gets the private link resources supported for the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :return: MHSMPrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateLinkResourceListResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.MHSMPrivateLinkResourceListResult] = kwargs.pop("cls", None) - - _request = build_list_by_mhsm_resource_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("MHSMPrivateLinkResourceListResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_operations.py deleted file mode 100644 index 02fa637fda73..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_operations.py +++ /dev/null @@ -1,152 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Iterable, Optional, Type, TypeVar -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_request(**kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/providers/Microsoft.KeyVault/operations") - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class Operations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2022_07_01.KeyVaultManagementClient`'s - :attr:`operations` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: - """Lists all of the available Key Vault Rest API operations. - - :return: An iterator like instance of either Operation or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.Operation] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("OperationListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_patch.py deleted file mode 100644 index 00994f70077d..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_patch.py +++ /dev/null @@ -1,134 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -import sys -from typing import Any, List, Iterable, Optional, Type -import urllib.parse - -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.rest import HttpRequest -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ._vaults_operations import VaultsOperations as _VaultsOperations, ClsType, build_list_request -from .. import models as _models - -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports - -class VaultsOperations(_VaultsOperations): - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - -__all__: List[str] = ["VaultsOperations"] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_private_link_resources_operations.py deleted file mode 100644 index c1e0215f2c8f..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_private_link_resources_operations.py +++ /dev/null @@ -1,145 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_by_vault_request( - resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class PrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2022_07_01.KeyVaultManagementClient`'s - :attr:`private_link_resources` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list_by_vault( - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> _models.PrivateLinkResourceListResult: - """Gets the private link resources supported for the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :return: PrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateLinkResourceListResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.PrivateLinkResourceListResult] = kwargs.pop("cls", None) - - _request = build_list_by_vault_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_secrets_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_secrets_operations.py deleted file mode 100644 index 29aa2ca5a50c..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_secrets_operations.py +++ /dev/null @@ -1,650 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Optional, Type, TypeVar, Union, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_or_update_request( - resource_group_name: str, vault_name: str, secret_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "secretName": _SERIALIZER.url("secret_name", secret_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_request( - resource_group_name: str, vault_name: str, secret_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "secretName": _SERIALIZER.url("secret_name", secret_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request( - resource_group_name: str, vault_name: str, secret_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "secretName": _SERIALIZER.url("secret_name", secret_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_request( - resource_group_name: str, vault_name: str, subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class SecretsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2022_07_01.KeyVaultManagementClient`'s - :attr:`secrets` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @overload - def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: _models.SecretCreateOrUpdateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. The value you provide may be copied globally for the - purpose of running the service. The value provided should not include personally identifiable - or sensitive information. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.SecretCreateOrUpdateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. The value you provide may be copied globally for the - purpose of running the service. The value provided should not include personally identifiable - or sensitive information. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def create_or_update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: Union[_models.SecretCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Secret: - """Create or update a secret in a key vault in the specified subscription. NOTE: This API is - intended for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. The value you provide may be copied globally for the - purpose of running the service. The value provided should not include personally identifiable - or sensitive information. Required. - :type secret_name: str - :param parameters: Parameters to create or update the secret. Is either a - SecretCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.SecretCreateOrUpdateParameters or - IO[bytes] - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "SecretCreateOrUpdateParameters") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: _models.SecretPatchParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.SecretPatchParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def update( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - parameters: Union[_models.SecretPatchParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Secret: - """Update a secret in the specified subscription. NOTE: This API is intended for internal use in - ARM deployments. Users should use the data-plane REST service for interaction with vault - secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param secret_name: Name of the secret. Required. - :type secret_name: str - :param parameters: Parameters to patch the secret. Is either a SecretPatchParameters type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.SecretPatchParameters or IO[bytes] - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "SecretPatchParameters") - - _request = build_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def get(self, resource_group_name: str, vault_name: str, secret_name: str, **kwargs: Any) -> _models.Secret: - """Gets the specified secret. NOTE: This API is intended for internal use in ARM deployments. - Users should use the data-plane REST service for interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param secret_name: The name of the secret. Required. - :type secret_name: str - :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Secret - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.Secret] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - secret_name=secret_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list( - self, resource_group_name: str, vault_name: str, top: Optional[int] = None, **kwargs: Any - ) -> Iterable["_models.Secret"]: - """The List operation gets information about the secrets in a vault. NOTE: This API is intended - for internal use in ARM deployments. Users should use the data-plane REST service for - interaction with vault secrets. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Secret or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.Secret] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.SecretListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("SecretListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_vaults_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_vaults_operations.py deleted file mode 100644 index ce0d14042d26..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_vaults_operations.py +++ /dev/null @@ -1,1581 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Literal, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_or_update_request( - resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_access_policy_request( - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "operationKind": _SERIALIZER.url("operation_kind", operation_kind, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_resource_group_request( - resource_group_name: str, subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_subscription_request( - subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_deleted_request(subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_deleted_request(vault_name: str, location: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "location": _SERIALIZER.url("location", location, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_purge_deleted_request(vault_name: str, location: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge", - ) # pylint: disable=line-too-long - path_format_arguments = { - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "location": _SERIALIZER.url("location", location, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_request(subscription_id: str, *, top: Optional[int] = None, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop("api_version", _params.pop("api-version", "2015-11-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resources") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["$filter"] = _SERIALIZER.query("filter", filter, "str") - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_check_name_availability_request(subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability" - ) - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -class VaultsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2022_07_01.KeyVaultManagementClient`'s - :attr:`vaults` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - def _create_or_update_initial( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 201: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.VaultCreateOrUpdateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2022_07_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2022_07_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> LROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Is either a - VaultCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.VaultCreateOrUpdateParameters or - IO[bytes] - :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2022_07_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._create_or_update_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("Vault", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.Vault].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.Vault]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @overload - def update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultPatchParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.VaultPatchParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultPatchParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Is either a VaultPatchParameters type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.VaultPatchParameters or IO[bytes] - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultPatchParameters") - - _request = build_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def delete( # pylint: disable=inconsistent-return-statements - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> None: - """Deletes the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault to delete. Required. - :type vault_name: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - @distributed_trace - def get(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> _models.Vault: - """Gets the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: _models.VaultAccessPolicyParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2022_07_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.VaultAccessPolicyParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2022_07_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: Union[_models.VaultAccessPolicyParameters, IO[bytes]], - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2022_07_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Is either a - VaultAccessPolicyParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.VaultAccessPolicyParameters or - IO[bytes] - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.VaultAccessPolicyParameters] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") - - _request = build_update_access_policy_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - operation_kind=operation_kind, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> Iterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription and - within the specified resource group. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedVault"]: - """Gets information about the deleted vaults in a subscription. - - :return: An iterator like instance of either DeletedVault or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.DeletedVault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.DeletedVaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("DeletedVaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _models.DeletedVault: - """Gets the deleted Azure key vault. - - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param location: The location of the deleted vault. Required. - :type location: str - :return: DeletedVault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.DeletedVault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[_models.DeletedVault] = kwargs.pop("cls", None) - - _request = build_get_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("DeletedVault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_purge_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_purge_deleted(self, vault_name: str, location: str, **kwargs: Any) -> LROPoller[None]: - """Permanently deletes the specified vault. aka Purges the deleted Azure key vault. - - :param vault_name: The name of the soft-deleted vault. Required. - :type vault_name: str - :param location: The location of the soft-deleted vault. Required. - :type location: str - :return: An instance of LROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._purge_deleted_initial( - vault_name=vault_name, - location=location, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @overload - def check_name_availability( - self, - vault_name: _models.VaultCheckNameAvailabilityParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: ~azure.mgmt.keyvault.v2022_07_01.models.VaultCheckNameAvailabilityParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def check_name_availability( - self, vault_name: IO[bytes], *, content_type: str = "application/json", **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def check_name_availability( - self, vault_name: Union[_models.VaultCheckNameAvailabilityParameters, IO[bytes]], **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Is either a VaultCheckNameAvailabilityParameters type - or a IO[bytes] type. Required. - :type vault_name: ~azure.mgmt.keyvault.v2022_07_01.models.VaultCheckNameAvailabilityParameters - or IO[bytes] - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.CheckNameAvailabilityResult] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(vault_name, (IOBase, bytes)): - _content = vault_name - else: - _json = self._serialize.body(vault_name, "VaultCheckNameAvailabilityParameters") - - _request = build_check_name_availability_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/py.typed b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/py.typed deleted file mode 100644 index e5aff4f83af8..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/py.typed +++ /dev/null @@ -1 +0,0 @@ -# Marker file for PEP 561. \ No newline at end of file diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/__init__.py index 6bb4b7c63a45..a60631755701 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/__init__.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/__init__.py @@ -5,15 +5,21 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +# pylint: disable=wrong-import-position -from ._key_vault_management_client import KeyVaultManagementClient +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._key_vault_management_client import KeyVaultManagementClient # type: ignore from ._version import VERSION __version__ = VERSION try: from ._patch import __all__ as _patch_all - from ._patch import * # pylint: disable=unused-wildcard-import + from ._patch import * except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk @@ -21,6 +27,6 @@ __all__ = [ "KeyVaultManagementClient", ] -__all__.extend([p for p in _patch_all if p not in __all__]) +__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/_configuration.py index 5d5c3612bf26..a4ab4811d622 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/_configuration.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/_configuration.py @@ -14,11 +14,10 @@ from ._version import VERSION if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials import TokenCredential -class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long +class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes """Configuration for KeyVaultManagementClient. Note that all parameters used to create this instance are saved as instance diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/_key_vault_management_client.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/_key_vault_management_client.py index a08e40f12be4..3556865920e2 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/_key_vault_management_client.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/_key_vault_management_client.py @@ -33,11 +33,10 @@ ) if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials import TokenCredential -class KeyVaultManagementClient: # pylint: disable=client-accepts-api-version-keyword,too-many-instance-attributes +class KeyVaultManagementClient: # pylint: disable=too-many-instance-attributes """The Azure management API provides a RESTful set of web services that interact with Azure Key Vault. diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/_version.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/_version.py index 3b99a1418535..e5754a47ce68 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/_version.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/_version.py @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "10.3.1" +VERSION = "1.0.0b1" diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/__init__.py index 6ba0c5a05353..30acffb8c4a7 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/__init__.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/__init__.py @@ -5,12 +5,18 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +# pylint: disable=wrong-import-position -from ._key_vault_management_client import KeyVaultManagementClient +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._key_vault_management_client import KeyVaultManagementClient # type: ignore try: from ._patch import __all__ as _patch_all - from ._patch import * # pylint: disable=unused-wildcard-import + from ._patch import * except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk @@ -18,6 +24,6 @@ __all__ = [ "KeyVaultManagementClient", ] -__all__.extend([p for p in _patch_all if p not in __all__]) +__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/_configuration.py index 626ed6cd7f71..6c84999365c9 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/_configuration.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/_configuration.py @@ -14,11 +14,10 @@ from .._version import VERSION if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials_async import AsyncTokenCredential -class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long +class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes """Configuration for KeyVaultManagementClient. Note that all parameters used to create this instance are saved as instance diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/_key_vault_management_client.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/_key_vault_management_client.py index 2137a7d64ca6..87521af71836 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/_key_vault_management_client.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/_key_vault_management_client.py @@ -33,11 +33,10 @@ ) if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials_async import AsyncTokenCredential -class KeyVaultManagementClient: # pylint: disable=client-accepts-api-version-keyword,too-many-instance-attributes +class KeyVaultManagementClient: # pylint: disable=too-many-instance-attributes """The Azure management API provides a RESTful set of web services that interact with Azure Key Vault. diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/__init__.py index 5f02a0a74b92..2c20c64a2fa5 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/__init__.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/__init__.py @@ -5,21 +5,27 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +# pylint: disable=wrong-import-position -from ._keys_operations import KeysOperations -from ._managed_hsm_keys_operations import ManagedHsmKeysOperations -from ._vaults_operations import VaultsOperations -from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations -from ._private_link_resources_operations import PrivateLinkResourcesOperations -from ._managed_hsms_operations import ManagedHsmsOperations -from ._mhsm_private_endpoint_connections_operations import MHSMPrivateEndpointConnectionsOperations -from ._mhsm_private_link_resources_operations import MHSMPrivateLinkResourcesOperations -from ._mhsm_regions_operations import MHSMRegionsOperations -from ._operations import Operations -from ._secrets_operations import SecretsOperations +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._keys_operations import KeysOperations # type: ignore +from ._managed_hsm_keys_operations import ManagedHsmKeysOperations # type: ignore +from ._vaults_operations import VaultsOperations # type: ignore +from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations # type: ignore +from ._private_link_resources_operations import PrivateLinkResourcesOperations # type: ignore +from ._managed_hsms_operations import ManagedHsmsOperations # type: ignore +from ._mhsm_private_endpoint_connections_operations import MHSMPrivateEndpointConnectionsOperations # type: ignore +from ._mhsm_private_link_resources_operations import MHSMPrivateLinkResourcesOperations # type: ignore +from ._mhsm_regions_operations import MHSMRegionsOperations # type: ignore +from ._operations import Operations # type: ignore +from ._secrets_operations import SecretsOperations # type: ignore from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import +from ._patch import * from ._patch import patch_sdk as _patch_sdk __all__ = [ @@ -35,5 +41,5 @@ "Operations", "SecretsOperations", ] -__all__.extend([p for p in _patch_all if p not in __all__]) +__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_keys_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_keys_operations.py index 2d3fd1723356..8b222eb2a3b5 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_keys_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_keys_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +7,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, Type, TypeVar, Union, overload +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList @@ -39,7 +38,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -161,7 +160,7 @@ async def create_if_not_exist( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.Key :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -231,7 +230,7 @@ async def get(self, resource_group_name: str, vault_name: str, key_name: str, ** :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.Key :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -293,7 +292,7 @@ def list(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> Asyn api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -375,7 +374,7 @@ async def get_version( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.Key :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -443,7 +442,7 @@ def list_versions( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_managed_hsm_keys_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_managed_hsm_keys_operations.py index 5faea30e084d..860232957bec 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_managed_hsm_keys_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_managed_hsm_keys_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +7,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, Type, TypeVar, Union, overload +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList @@ -39,7 +38,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -162,7 +161,7 @@ async def create_if_not_exist( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.ManagedHsmKey :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -234,7 +233,7 @@ async def get(self, resource_group_name: str, name: str, key_name: str, **kwargs :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.ManagedHsmKey :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -297,7 +296,7 @@ def list(self, resource_group_name: str, name: str, **kwargs: Any) -> AsyncItera api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.ManagedHsmKeyListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -380,7 +379,7 @@ async def get_version( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.ManagedHsmKey :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -450,7 +449,7 @@ def list_versions( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.ManagedHsmKeyListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_managed_hsms_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_managed_hsms_operations.py index 43ab889e79cd..cb0c685866d7 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_managed_hsms_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_managed_hsms_operations.py @@ -1,4 +1,4 @@ -# pylint: disable=too-many-lines,too-many-statements +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +8,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, Type, TypeVar, Union, cast, overload +from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList @@ -18,6 +18,8 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.pipeline import PipelineResponse @@ -46,7 +48,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -74,7 +76,7 @@ def __init__(self, *args, **kwargs) -> None: async def _create_or_update_initial( self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -110,6 +112,7 @@ async def _create_or_update_initial( ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -118,19 +121,19 @@ async def _create_or_update_initial( response = pipeline_response.http_response if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - if response.status_code == 202: response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -262,7 +265,7 @@ def get_long_running_output(pipeline_response): async def _update_initial( self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -298,6 +301,7 @@ async def _update_initial( ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -306,19 +310,19 @@ async def _update_initial( response = pipeline_response.http_response if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - if response.status_code == 202: response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -448,7 +452,7 @@ def get_long_running_output(pipeline_response): ) async def _delete_initial(self, resource_group_name: str, name: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -472,6 +476,7 @@ async def _delete_initial(self, resource_group_name: str, name: str, **kwargs: A ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -480,22 +485,19 @@ async def _delete_initial(self, resource_group_name: str, name: str, **kwargs: A response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: - await response.read() # Load the body in memory and close the socket + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - if response.status_code == 202: response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -568,7 +570,7 @@ async def get(self, resource_group_name: str, name: str, **kwargs: Any) -> Optio :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.ManagedHsm or None :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -636,7 +638,7 @@ def list_by_resource_group( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -717,7 +719,7 @@ def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> Asyn api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -795,7 +797,7 @@ def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedManagedHs api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.DeletedManagedHsmListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -868,7 +870,7 @@ async def get_deleted(self, name: str, location: str, **kwargs: Any) -> _models. :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.DeletedManagedHsm :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -912,7 +914,7 @@ async def get_deleted(self, name: str, location: str, **kwargs: Any) -> _models. return deserialized # type: ignore async def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -936,6 +938,7 @@ async def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -944,7 +947,10 @@ async def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) response = pipeline_response.http_response if response.status_code not in [202]: - await response.read() # Load the body in memory and close the socket + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) @@ -952,7 +958,7 @@ async def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) response_headers = {} response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -1061,7 +1067,7 @@ async def check_mhsm_name_availability( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.CheckMhsmNameAvailabilityResult :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_mhsm_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_mhsm_private_endpoint_connections_operations.py index 4a0fcd73392c..ea77aa75953d 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_mhsm_private_endpoint_connections_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_mhsm_private_endpoint_connections_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +7,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, Type, TypeVar, Union, cast, overload +from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList @@ -18,6 +17,8 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.pipeline import PipelineResponse @@ -40,7 +41,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -89,7 +90,7 @@ def list_by_resource( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -170,7 +171,7 @@ async def get( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.MHSMPrivateEndpointConnection :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -303,7 +304,7 @@ async def put( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.MHSMPrivateEndpointConnection :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -367,7 +368,7 @@ async def put( async def _delete_initial( self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -392,6 +393,7 @@ async def _delete_initial( ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -400,21 +402,18 @@ async def _delete_initial( response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: - await response.read() # Load the body in memory and close the socket + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - if response.status_code == 202: response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_mhsm_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_mhsm_private_link_resources_operations.py index 649f70c4ebe1..05cd256e2da5 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_mhsm_private_link_resources_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_mhsm_private_link_resources_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,7 +6,7 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar +from typing import Any, Callable, Dict, Optional, TypeVar from azure.core.exceptions import ( ClientAuthenticationError, @@ -29,7 +28,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -69,7 +68,7 @@ async def list_by_mhsm_resource( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.MHSMPrivateLinkResourceListResult :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_mhsm_regions_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_mhsm_regions_operations.py index 6e1c4ee010e7..dd22e8d79480 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_mhsm_regions_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_mhsm_regions_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,7 +6,7 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import sys -from typing import Any, AsyncIterable, Callable, Dict, Optional, Type, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList @@ -31,7 +30,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -79,7 +78,7 @@ def list_by_resource( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.MHSMRegionsListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_operations.py index 6b03ecf7d890..5f496caa1225 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,7 +6,7 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import sys -from typing import Any, AsyncIterable, Callable, Dict, Optional, Type, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList @@ -31,7 +30,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -71,7 +70,7 @@ def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_patch.py index 9b4f32f151b7..a22e2c723f41 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_patch.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_patch.py @@ -38,6 +38,7 @@ else: from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + class VaultsOperations(_VaultsOperations): @distributed_trace @@ -57,9 +58,7 @@ def list(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_mode filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", "2015-11-01") - ) + api_version: Literal["2015-11-01"] = kwargs.pop("api_version", _params.pop("api-version", "2015-11-01")) cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) error_map: MutableMapping[int, Type[HttpResponseError]] = { @@ -124,6 +123,7 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) + __all__: List[str] = ["VaultsOperations"] # Add all objects you want publicly available to users at this package level diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_private_endpoint_connections_operations.py index a511134a04bf..dbbf3b1344df 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_private_endpoint_connections_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_private_endpoint_connections_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +7,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, Type, TypeVar, Union, cast, overload +from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList @@ -18,6 +17,8 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.pipeline import PipelineResponse @@ -40,7 +41,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -82,7 +83,7 @@ async def get( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.PrivateEndpointConnection or None :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -213,7 +214,7 @@ async def put( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.PrivateEndpointConnection :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -277,7 +278,7 @@ async def put( async def _delete_initial( self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -302,6 +303,7 @@ async def _delete_initial( ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -310,22 +312,19 @@ async def _delete_initial( response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: - await response.read() # Load the body in memory and close the socket + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - if response.status_code == 202: response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -419,7 +418,7 @@ def list_by_resource( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.PrivateEndpointConnectionListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_private_link_resources_operations.py index 626a7d4cf237..85a3dcfb0a32 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_private_link_resources_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_private_link_resources_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,7 +6,7 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar +from typing import Any, Callable, Dict, Optional, TypeVar from azure.core.exceptions import ( ClientAuthenticationError, @@ -29,7 +28,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -68,7 +67,7 @@ async def list_by_vault( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.PrivateLinkResourceListResult :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_secrets_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_secrets_operations.py index 73359761cad9..1a6dac4376df 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_secrets_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_secrets_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +7,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, Type, TypeVar, Union, overload +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList @@ -38,7 +37,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -161,7 +160,7 @@ async def create_or_update( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.Secret :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -209,11 +208,7 @@ async def create_or_update( map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) + deserialized = self._deserialize("Secret", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -311,7 +306,7 @@ async def update( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.Secret :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -359,11 +354,7 @@ async def update( map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) + deserialized = self._deserialize("Secret", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -386,7 +377,7 @@ async def get(self, resource_group_name: str, vault_name: str, secret_name: str, :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.Secret :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -454,7 +445,7 @@ def list( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.SecretListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_vaults_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_vaults_operations.py index a449a47e5a69..533b4237fba9 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_vaults_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/aio/operations/_vaults_operations.py @@ -1,4 +1,4 @@ -# pylint: disable=too-many-lines,too-many-statements +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -17,7 +17,6 @@ IO, Literal, Optional, - Type, TypeVar, Union, cast, @@ -32,6 +31,8 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.pipeline import PipelineResponse @@ -62,7 +63,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -94,7 +95,7 @@ async def _create_or_update_initial( parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], **kwargs: Any ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -130,6 +131,7 @@ async def _create_or_update_initial( ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -138,15 +140,14 @@ async def _create_or_update_initial( response = pipeline_response.http_response if response.status_code not in [200, 201]: - await response.read() # Load the body in memory and close the socket + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 201: - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -353,7 +354,7 @@ async def update( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.Vault :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -400,11 +401,7 @@ async def update( map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Vault", pipeline_response.http_response) + deserialized = self._deserialize("Vault", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -412,9 +409,7 @@ async def update( return deserialized # type: ignore @distributed_trace_async - async def delete( # pylint: disable=inconsistent-return-statements - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> None: + async def delete(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> None: """Deletes the specified Azure key vault. :param resource_group_name: The name of the Resource Group to which the vault belongs. @@ -426,7 +421,7 @@ async def delete( # pylint: disable=inconsistent-return-statements :rtype: None :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -477,7 +472,7 @@ async def get(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.Vault :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -608,7 +603,7 @@ async def update_access_policy( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.VaultAccessPolicyParameters :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -656,11 +651,7 @@ async def update_access_policy( map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -689,7 +680,7 @@ def list_by_resource_group( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -767,7 +758,7 @@ def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> Asyn api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -843,7 +834,7 @@ def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedVault"]: api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.DeletedVaultListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -915,7 +906,7 @@ async def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _m :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.DeletedVault :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -958,7 +949,7 @@ async def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _m return deserialized # type: ignore async def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -982,6 +973,7 @@ async def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -990,15 +982,14 @@ async def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: response = pipeline_response.http_response if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -1079,7 +1070,7 @@ def list(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_mode ) cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1191,7 +1182,7 @@ async def check_name_availability( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.CheckNameAvailabilityResult :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/models/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/models/__init__.py index eff496572923..aee96ad439fd 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/models/__init__.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/models/__init__.py @@ -5,130 +5,141 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +# pylint: disable=wrong-import-position -from ._models_py3 import AccessPolicyEntry -from ._models_py3 import Action -from ._models_py3 import Attributes -from ._models_py3 import CheckMhsmNameAvailabilityParameters -from ._models_py3 import CheckMhsmNameAvailabilityResult -from ._models_py3 import CheckNameAvailabilityResult -from ._models_py3 import CloudErrorBody -from ._models_py3 import DeletedManagedHsm -from ._models_py3 import DeletedManagedHsmListResult -from ._models_py3 import DeletedManagedHsmProperties -from ._models_py3 import DeletedVault -from ._models_py3 import DeletedVaultListResult -from ._models_py3 import DeletedVaultProperties -from ._models_py3 import DimensionProperties -from ._models_py3 import Error -from ._models_py3 import IPRule -from ._models_py3 import Key -from ._models_py3 import KeyAttributes -from ._models_py3 import KeyCreateParameters -from ._models_py3 import KeyListResult -from ._models_py3 import KeyProperties -from ._models_py3 import KeyReleasePolicy -from ._models_py3 import KeyRotationPolicyAttributes -from ._models_py3 import LifetimeAction -from ._models_py3 import LogSpecification -from ._models_py3 import MHSMGeoReplicatedRegion -from ._models_py3 import MHSMIPRule -from ._models_py3 import MHSMNetworkRuleSet -from ._models_py3 import MHSMPrivateEndpoint -from ._models_py3 import MHSMPrivateEndpointConnection -from ._models_py3 import MHSMPrivateEndpointConnectionItem -from ._models_py3 import MHSMPrivateEndpointConnectionsListResult -from ._models_py3 import MHSMPrivateLinkResource -from ._models_py3 import MHSMPrivateLinkResourceListResult -from ._models_py3 import MHSMPrivateLinkServiceConnectionState -from ._models_py3 import MHSMRegionsListResult -from ._models_py3 import MHSMVirtualNetworkRule -from ._models_py3 import ManagedHSMSecurityDomainProperties -from ._models_py3 import ManagedHsm -from ._models_py3 import ManagedHsmAction -from ._models_py3 import ManagedHsmError -from ._models_py3 import ManagedHsmKey -from ._models_py3 import ManagedHsmKeyAttributes -from ._models_py3 import ManagedHsmKeyCreateParameters -from ._models_py3 import ManagedHsmKeyListResult -from ._models_py3 import ManagedHsmKeyProperties -from ._models_py3 import ManagedHsmKeyReleasePolicy -from ._models_py3 import ManagedHsmKeyRotationPolicyAttributes -from ._models_py3 import ManagedHsmLifetimeAction -from ._models_py3 import ManagedHsmListResult -from ._models_py3 import ManagedHsmProperties -from ._models_py3 import ManagedHsmResource -from ._models_py3 import ManagedHsmRotationPolicy -from ._models_py3 import ManagedHsmSku -from ._models_py3 import ManagedHsmTrigger -from ._models_py3 import MetricSpecification -from ._models_py3 import NetworkRuleSet -from ._models_py3 import Operation -from ._models_py3 import OperationDisplay -from ._models_py3 import OperationListResult -from ._models_py3 import Permissions -from ._models_py3 import PrivateEndpoint -from ._models_py3 import PrivateEndpointConnection -from ._models_py3 import PrivateEndpointConnectionItem -from ._models_py3 import PrivateEndpointConnectionListResult -from ._models_py3 import PrivateLinkResource -from ._models_py3 import PrivateLinkResourceListResult -from ._models_py3 import PrivateLinkServiceConnectionState -from ._models_py3 import ProxyResourceWithoutSystemData -from ._models_py3 import Resource -from ._models_py3 import ResourceListResult -from ._models_py3 import RotationPolicy -from ._models_py3 import Secret -from ._models_py3 import SecretAttributes -from ._models_py3 import SecretCreateOrUpdateParameters -from ._models_py3 import SecretListResult -from ._models_py3 import SecretPatchParameters -from ._models_py3 import SecretPatchProperties -from ._models_py3 import SecretProperties -from ._models_py3 import ServiceSpecification -from ._models_py3 import Sku -from ._models_py3 import SystemData -from ._models_py3 import Trigger -from ._models_py3 import Vault -from ._models_py3 import VaultAccessPolicyParameters -from ._models_py3 import VaultAccessPolicyProperties -from ._models_py3 import VaultCheckNameAvailabilityParameters -from ._models_py3 import VaultCreateOrUpdateParameters -from ._models_py3 import VaultListResult -from ._models_py3 import VaultPatchParameters -from ._models_py3 import VaultPatchProperties -from ._models_py3 import VaultProperties -from ._models_py3 import VirtualNetworkRule +from typing import TYPE_CHECKING -from ._key_vault_management_client_enums import AccessPolicyUpdateKind -from ._key_vault_management_client_enums import ActionsRequired -from ._key_vault_management_client_enums import ActivationStatus -from ._key_vault_management_client_enums import CertificatePermissions -from ._key_vault_management_client_enums import CreateMode -from ._key_vault_management_client_enums import DeletionRecoveryLevel -from ._key_vault_management_client_enums import GeoReplicationRegionProvisioningState -from ._key_vault_management_client_enums import IdentityType -from ._key_vault_management_client_enums import JsonWebKeyCurveName -from ._key_vault_management_client_enums import JsonWebKeyOperation -from ._key_vault_management_client_enums import JsonWebKeyType -from ._key_vault_management_client_enums import KeyPermissions -from ._key_vault_management_client_enums import KeyRotationPolicyActionType -from ._key_vault_management_client_enums import ManagedHsmSkuFamily -from ._key_vault_management_client_enums import ManagedHsmSkuName -from ._key_vault_management_client_enums import NetworkRuleAction -from ._key_vault_management_client_enums import NetworkRuleBypassOptions -from ._key_vault_management_client_enums import PrivateEndpointConnectionProvisioningState -from ._key_vault_management_client_enums import PrivateEndpointServiceConnectionStatus -from ._key_vault_management_client_enums import ProvisioningState -from ._key_vault_management_client_enums import PublicNetworkAccess -from ._key_vault_management_client_enums import Reason -from ._key_vault_management_client_enums import SecretPermissions -from ._key_vault_management_client_enums import SkuFamily -from ._key_vault_management_client_enums import SkuName -from ._key_vault_management_client_enums import StoragePermissions -from ._key_vault_management_client_enums import VaultProvisioningState +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + + +from ._models_py3 import ( # type: ignore + AccessPolicyEntry, + Action, + Attributes, + CheckMhsmNameAvailabilityParameters, + CheckMhsmNameAvailabilityResult, + CheckNameAvailabilityResult, + CloudErrorBody, + DeletedManagedHsm, + DeletedManagedHsmListResult, + DeletedManagedHsmProperties, + DeletedVault, + DeletedVaultListResult, + DeletedVaultProperties, + DimensionProperties, + Error, + IPRule, + Key, + KeyAttributes, + KeyCreateParameters, + KeyListResult, + KeyProperties, + KeyReleasePolicy, + KeyRotationPolicyAttributes, + LifetimeAction, + LogSpecification, + MHSMGeoReplicatedRegion, + MHSMIPRule, + MHSMNetworkRuleSet, + MHSMPrivateEndpoint, + MHSMPrivateEndpointConnection, + MHSMPrivateEndpointConnectionItem, + MHSMPrivateEndpointConnectionsListResult, + MHSMPrivateLinkResource, + MHSMPrivateLinkResourceListResult, + MHSMPrivateLinkServiceConnectionState, + MHSMRegionsListResult, + MHSMVirtualNetworkRule, + ManagedHSMSecurityDomainProperties, + ManagedHsm, + ManagedHsmAction, + ManagedHsmError, + ManagedHsmKey, + ManagedHsmKeyAttributes, + ManagedHsmKeyCreateParameters, + ManagedHsmKeyListResult, + ManagedHsmKeyProperties, + ManagedHsmKeyReleasePolicy, + ManagedHsmKeyRotationPolicyAttributes, + ManagedHsmLifetimeAction, + ManagedHsmListResult, + ManagedHsmProperties, + ManagedHsmResource, + ManagedHsmRotationPolicy, + ManagedHsmSku, + ManagedHsmTrigger, + MetricSpecification, + NetworkRuleSet, + Operation, + OperationDisplay, + OperationListResult, + Permissions, + PrivateEndpoint, + PrivateEndpointConnection, + PrivateEndpointConnectionItem, + PrivateEndpointConnectionListResult, + PrivateLinkResource, + PrivateLinkResourceListResult, + PrivateLinkServiceConnectionState, + ProxyResourceWithoutSystemData, + Resource, + ResourceListResult, + RotationPolicy, + Secret, + SecretAttributes, + SecretCreateOrUpdateParameters, + SecretListResult, + SecretPatchParameters, + SecretPatchProperties, + SecretProperties, + ServiceSpecification, + Sku, + SystemData, + Trigger, + Vault, + VaultAccessPolicyParameters, + VaultAccessPolicyProperties, + VaultCheckNameAvailabilityParameters, + VaultCreateOrUpdateParameters, + VaultListResult, + VaultPatchParameters, + VaultPatchProperties, + VaultProperties, + VirtualNetworkRule, +) + +from ._key_vault_management_client_enums import ( # type: ignore + AccessPolicyUpdateKind, + ActionsRequired, + ActivationStatus, + CertificatePermissions, + CreateMode, + DeletionRecoveryLevel, + GeoReplicationRegionProvisioningState, + IdentityType, + JsonWebKeyCurveName, + JsonWebKeyOperation, + JsonWebKeyType, + KeyPermissions, + KeyRotationPolicyActionType, + ManagedHsmSkuFamily, + ManagedHsmSkuName, + NetworkRuleAction, + NetworkRuleBypassOptions, + PrivateEndpointConnectionProvisioningState, + PrivateEndpointServiceConnectionStatus, + ProvisioningState, + PublicNetworkAccess, + Reason, + SecretPermissions, + SkuFamily, + SkuName, + StoragePermissions, + VaultProvisioningState, +) from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import +from ._patch import * from ._patch import patch_sdk as _patch_sdk __all__ = [ @@ -253,5 +264,5 @@ "StoragePermissions", "VaultProvisioningState", ] -__all__.extend([p for p in _patch_all if p not in __all__]) +__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/models/_models_py3.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/models/_models_py3.py index 16f4acba1b83..5e0b179c5da7 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/models/_models_py3.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/models/_models_py3.py @@ -1,5 +1,5 @@ -# coding=utf-8 # pylint: disable=too-many-lines +# coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. @@ -13,7 +13,6 @@ from ... import _serialization if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from .. import models as _models @@ -664,7 +663,7 @@ def __init__(self, **kwargs: Any) -> None: self.tags = None -class Key(Resource): # pylint: disable=too-many-instance-attributes +class Key(Resource): """The key resource. Variables are only populated by the server, and will be ignored when sending a request. @@ -1347,7 +1346,7 @@ def __init__(self, *, tags: Optional[Dict[str, str]] = None, **kwargs: Any) -> N self.tags = tags -class ManagedHsmKey(ProxyResourceWithoutSystemData): # pylint: disable=too-many-instance-attributes +class ManagedHsmKey(ProxyResourceWithoutSystemData): """The key resource. Variables are only populated by the server, and will be ignored when sending a request. @@ -1804,7 +1803,7 @@ def __init__( self.next_link = next_link -class ManagedHsmProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes +class ManagedHsmProperties(_serialization.Model): """Properties of the managed HSM Pool. Variables are only populated by the server, and will be ignored when sending a request. @@ -2091,7 +2090,7 @@ def __init__( self.time_before_expiry = time_before_expiry -class MetricSpecification(_serialization.Model): # pylint: disable=too-many-instance-attributes +class MetricSpecification(_serialization.Model): """Metric specification of operation. :ivar name: Name of metric specification. @@ -2336,7 +2335,7 @@ def __init__(self, **kwargs: Any) -> None: self.id = None -class MHSMPrivateEndpointConnection(ManagedHsmResource): # pylint: disable=too-many-instance-attributes +class MHSMPrivateEndpointConnection(ManagedHsmResource): """Private endpoint connection resource. Variables are only populated by the server, and will be ignored when sending a request. @@ -4045,7 +4044,7 @@ def __init__( self.properties = properties -class VaultPatchProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes +class VaultPatchProperties(_serialization.Model): """Properties of the vault. :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating @@ -4195,7 +4194,7 @@ def __init__( self.public_network_access = public_network_access -class VaultProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes +class VaultProperties(_serialization.Model): """Properties of the vault. Variables are only populated by the server, and will be ignored when sending a request. diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/__init__.py index 5f02a0a74b92..2c20c64a2fa5 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/__init__.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/__init__.py @@ -5,21 +5,27 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +# pylint: disable=wrong-import-position -from ._keys_operations import KeysOperations -from ._managed_hsm_keys_operations import ManagedHsmKeysOperations -from ._vaults_operations import VaultsOperations -from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations -from ._private_link_resources_operations import PrivateLinkResourcesOperations -from ._managed_hsms_operations import ManagedHsmsOperations -from ._mhsm_private_endpoint_connections_operations import MHSMPrivateEndpointConnectionsOperations -from ._mhsm_private_link_resources_operations import MHSMPrivateLinkResourcesOperations -from ._mhsm_regions_operations import MHSMRegionsOperations -from ._operations import Operations -from ._secrets_operations import SecretsOperations +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._keys_operations import KeysOperations # type: ignore +from ._managed_hsm_keys_operations import ManagedHsmKeysOperations # type: ignore +from ._vaults_operations import VaultsOperations # type: ignore +from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations # type: ignore +from ._private_link_resources_operations import PrivateLinkResourcesOperations # type: ignore +from ._managed_hsms_operations import ManagedHsmsOperations # type: ignore +from ._mhsm_private_endpoint_connections_operations import MHSMPrivateEndpointConnectionsOperations # type: ignore +from ._mhsm_private_link_resources_operations import MHSMPrivateLinkResourcesOperations # type: ignore +from ._mhsm_regions_operations import MHSMRegionsOperations # type: ignore +from ._operations import Operations # type: ignore +from ._secrets_operations import SecretsOperations # type: ignore from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import +from ._patch import * from ._patch import patch_sdk as _patch_sdk __all__ = [ @@ -35,5 +41,5 @@ "Operations", "SecretsOperations", ] -__all__.extend([p for p in _patch_all if p not in __all__]) +__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_keys_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_keys_operations.py index 286092974128..ebebe26bb779 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_keys_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_keys_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +7,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, Callable, Dict, IO, Iterable, Optional, Type, TypeVar, Union, overload +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload import urllib.parse from azure.core.exceptions import ( @@ -32,7 +31,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -318,7 +317,7 @@ def create_if_not_exist( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.Key :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -388,7 +387,7 @@ def get(self, resource_group_name: str, vault_name: str, key_name: str, **kwargs :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.Key :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -450,7 +449,7 @@ def list(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> Iter api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -532,7 +531,7 @@ def get_version( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.Key :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -600,7 +599,7 @@ def list_versions( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_managed_hsm_keys_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_managed_hsm_keys_operations.py index fe06c26a064c..794862e729ee 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_managed_hsm_keys_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_managed_hsm_keys_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +7,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, Callable, Dict, IO, Iterable, Optional, Type, TypeVar, Union, overload +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload import urllib.parse from azure.core.exceptions import ( @@ -32,7 +31,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -339,7 +338,7 @@ def create_if_not_exist( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.ManagedHsmKey :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -411,7 +410,7 @@ def get(self, resource_group_name: str, name: str, key_name: str, **kwargs: Any) :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.ManagedHsmKey :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -473,7 +472,7 @@ def list(self, resource_group_name: str, name: str, **kwargs: Any) -> Iterable[" api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.ManagedHsmKeyListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -556,7 +555,7 @@ def get_version( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.ManagedHsmKey :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -625,7 +624,7 @@ def list_versions( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.ManagedHsmKeyListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_managed_hsms_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_managed_hsms_operations.py index 8e8a56459c1c..307e5e360f23 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_managed_hsms_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_managed_hsms_operations.py @@ -1,4 +1,4 @@ -# pylint: disable=too-many-lines,too-many-statements +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +8,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, Type, TypeVar, Union, cast, overload +from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, TypeVar, Union, cast, overload import urllib.parse from azure.core.exceptions import ( @@ -17,6 +17,8 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.paging import ItemPaged @@ -34,7 +36,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -362,7 +364,7 @@ def __init__(self, *args, **kwargs): def _create_or_update_initial( self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -398,6 +400,7 @@ def _create_or_update_initial( ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -406,19 +409,19 @@ def _create_or_update_initial( response = pipeline_response.http_response if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - if response.status_code == 202: response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -547,7 +550,7 @@ def get_long_running_output(pipeline_response): def _update_initial( self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -583,6 +586,7 @@ def _update_initial( ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -591,19 +595,19 @@ def _update_initial( response = pipeline_response.http_response if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - if response.status_code == 202: response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -730,7 +734,7 @@ def get_long_running_output(pipeline_response): ) def _delete_initial(self, resource_group_name: str, name: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -754,6 +758,7 @@ def _delete_initial(self, resource_group_name: str, name: str, **kwargs: Any) -> ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -762,22 +767,19 @@ def _delete_initial(self, resource_group_name: str, name: str, **kwargs: Any) -> response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: - response.read() # Load the body in memory and close the socket + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - if response.status_code == 202: response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -850,7 +852,7 @@ def get(self, resource_group_name: str, name: str, **kwargs: Any) -> Optional[_m :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.ManagedHsm or None :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -917,7 +919,7 @@ def list_by_resource_group( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -997,7 +999,7 @@ def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> Iter api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1074,7 +1076,7 @@ def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedManagedHsm"]: api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.DeletedManagedHsmListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1147,7 +1149,7 @@ def get_deleted(self, name: str, location: str, **kwargs: Any) -> _models.Delete :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.DeletedManagedHsm :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1191,7 +1193,7 @@ def get_deleted(self, name: str, location: str, **kwargs: Any) -> _models.Delete return deserialized # type: ignore def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1215,6 +1217,7 @@ def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) -> Ite ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -1223,7 +1226,10 @@ def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) -> Ite response = pipeline_response.http_response if response.status_code not in [202]: - response.read() # Load the body in memory and close the socket + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) @@ -1231,7 +1237,7 @@ def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) -> Ite response_headers = {} response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -1340,7 +1346,7 @@ def check_mhsm_name_availability( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.CheckMhsmNameAvailabilityResult :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_mhsm_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_mhsm_private_endpoint_connections_operations.py index 0fabfdc46d5f..9735590214c1 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_mhsm_private_endpoint_connections_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_mhsm_private_endpoint_connections_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +7,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, Type, TypeVar, Union, cast, overload +from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, TypeVar, Union, cast, overload import urllib.parse from azure.core.exceptions import ( @@ -17,6 +16,8 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.paging import ItemPaged @@ -34,7 +35,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -222,7 +223,7 @@ def list_by_resource( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -303,7 +304,7 @@ def get( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.MHSMPrivateEndpointConnection :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -436,7 +437,7 @@ def put( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.MHSMPrivateEndpointConnection :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -500,7 +501,7 @@ def put( def _delete_initial( self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -525,6 +526,7 @@ def _delete_initial( ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -533,21 +535,18 @@ def _delete_initial( response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: - response.read() # Load the body in memory and close the socket + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - if response.status_code == 202: response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_mhsm_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_mhsm_private_link_resources_operations.py index 16aec130c9e2..8643effc3f05 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_mhsm_private_link_resources_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_mhsm_private_link_resources_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,7 +6,7 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar +from typing import Any, Callable, Dict, Optional, TypeVar from azure.core.exceptions import ( ClientAuthenticationError, @@ -29,7 +28,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -103,7 +102,7 @@ def list_by_mhsm_resource( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.MHSMPrivateLinkResourceListResult :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_mhsm_regions_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_mhsm_regions_operations.py index 5ad97fc01907..020547eff595 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_mhsm_regions_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_mhsm_regions_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,7 +6,7 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import sys -from typing import Any, Callable, Dict, Iterable, Optional, Type, TypeVar +from typing import Any, Callable, Dict, Iterable, Optional, TypeVar import urllib.parse from azure.core.exceptions import ( @@ -31,7 +30,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -113,7 +112,7 @@ def list_by_resource( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.MHSMRegionsListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_operations.py index b27bd571d68d..a9151a716181 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,7 +6,7 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import sys -from typing import Any, Callable, Dict, Iterable, Optional, Type, TypeVar +from typing import Any, Callable, Dict, Iterable, Optional, TypeVar import urllib.parse from azure.core.exceptions import ( @@ -31,7 +30,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -92,7 +91,7 @@ def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_patch.py index 59bec6bbc7f5..d81ad1a571ba 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_patch.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_patch.py @@ -37,6 +37,7 @@ else: from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + class VaultsOperations(_VaultsOperations): @distributed_trace def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Resource"]: @@ -54,9 +55,7 @@ def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Re filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", "2015-11-01") - ) + api_version: Literal["2015-11-01"] = kwargs.pop("api_version", _params.pop("api-version", "2015-11-01")) cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) error_map: MutableMapping[int, Type[HttpResponseError]] = { diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_private_endpoint_connections_operations.py index f948531314d9..24bcb15582d1 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_private_endpoint_connections_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_private_endpoint_connections_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +7,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, Type, TypeVar, Union, cast, overload +from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, TypeVar, Union, cast, overload import urllib.parse from azure.core.exceptions import ( @@ -17,6 +16,8 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.paging import ItemPaged @@ -34,7 +35,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -227,7 +228,7 @@ def get( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.PrivateEndpointConnection or None :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -358,7 +359,7 @@ def put( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.PrivateEndpointConnection :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -422,7 +423,7 @@ def put( def _delete_initial( self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -447,6 +448,7 @@ def _delete_initial( ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -455,22 +457,19 @@ def _delete_initial( response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: - response.read() # Load the body in memory and close the socket + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - if response.status_code == 202: response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -564,7 +563,7 @@ def list_by_resource( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.PrivateEndpointConnectionListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_private_link_resources_operations.py index 200436074208..38a5ddb7e041 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_private_link_resources_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_private_link_resources_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,7 +6,7 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar +from typing import Any, Callable, Dict, Optional, TypeVar from azure.core.exceptions import ( ClientAuthenticationError, @@ -29,7 +28,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -102,7 +101,7 @@ def list_by_vault( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.PrivateLinkResourceListResult :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_secrets_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_secrets_operations.py index d6480ccb30a9..4559b1bfd06d 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_secrets_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_secrets_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +7,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, Callable, Dict, IO, Iterable, Optional, Type, TypeVar, Union, overload +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload import urllib.parse from azure.core.exceptions import ( @@ -32,7 +31,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -293,7 +292,7 @@ def create_or_update( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.Secret :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -341,11 +340,7 @@ def create_or_update( map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) + deserialized = self._deserialize("Secret", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -443,7 +438,7 @@ def update( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.Secret :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -491,11 +486,7 @@ def update( map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) + deserialized = self._deserialize("Secret", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -518,7 +509,7 @@ def get(self, resource_group_name: str, vault_name: str, secret_name: str, **kwa :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.Secret :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -586,7 +577,7 @@ def list( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.SecretListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_vaults_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_vaults_operations.py index 85ae57ea45a2..493d18171e7b 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_vaults_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_02_01/operations/_vaults_operations.py @@ -1,4 +1,4 @@ -# pylint: disable=too-many-lines,too-many-statements +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +8,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Literal, Optional, Type, TypeVar, Union, cast, overload +from typing import Any, Callable, Dict, IO, Iterable, Iterator, Literal, Optional, TypeVar, Union, cast, overload import urllib.parse from azure.core.exceptions import ( @@ -17,6 +17,8 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.paging import ItemPaged @@ -34,7 +36,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -433,7 +435,7 @@ def _create_or_update_initial( parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], **kwargs: Any ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -469,6 +471,7 @@ def _create_or_update_initial( ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -477,15 +480,14 @@ def _create_or_update_initial( response = pipeline_response.http_response if response.status_code not in [200, 201]: - response.read() # Load the body in memory and close the socket + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 201: - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -692,7 +694,7 @@ def update( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.Vault :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -739,11 +741,7 @@ def update( map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Vault", pipeline_response.http_response) + deserialized = self._deserialize("Vault", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -765,7 +763,7 @@ def delete( # pylint: disable=inconsistent-return-statements :rtype: None :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -816,7 +814,7 @@ def get(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> _mode :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.Vault :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -947,7 +945,7 @@ def update_access_policy( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.VaultAccessPolicyParameters :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -995,11 +993,7 @@ def update_access_policy( map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -1028,7 +1022,7 @@ def list_by_resource_group( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1106,7 +1100,7 @@ def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> Iter api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1181,7 +1175,7 @@ def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedVault"]: api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-02-01")) cls: ClsType[_models.DeletedVaultListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1253,7 +1247,7 @@ def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _models. :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.DeletedVault :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1296,7 +1290,7 @@ def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _models. return deserialized # type: ignore def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1320,6 +1314,7 @@ def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -1328,15 +1323,14 @@ def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) response = pipeline_response.http_response if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -1416,7 +1410,7 @@ def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Re ) cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1528,7 +1522,7 @@ def check_name_availability( :rtype: ~azure.mgmt.keyvault.v2023_02_01.models.CheckNameAvailabilityResult :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/__init__.py deleted file mode 100644 index 6bb4b7c63a45..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/__init__.py +++ /dev/null @@ -1,26 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._key_vault_management_client import KeyVaultManagementClient -from ._version import VERSION - -__version__ = VERSION - -try: - from ._patch import __all__ as _patch_all - from ._patch import * # pylint: disable=unused-wildcard-import -except ImportError: - _patch_all = [] -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "KeyVaultManagementClient", -] -__all__.extend([p for p in _patch_all if p not in __all__]) - -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/_configuration.py deleted file mode 100644 index da014f6a75a7..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/_configuration.py +++ /dev/null @@ -1,66 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from typing import Any, TYPE_CHECKING - -from azure.core.pipeline import policies -from azure.mgmt.core.policies import ARMChallengeAuthenticationPolicy, ARMHttpLoggingPolicy - -from ._version import VERSION - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials import TokenCredential - - -class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long - """Configuration for KeyVaultManagementClient. - - Note that all parameters used to create this instance are saved as instance - attributes. - - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials.TokenCredential - :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. Required. - :type subscription_id: str - :keyword api_version: Api Version. Default value is "2023-07-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str - """ - - def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None: - api_version: str = kwargs.pop("api_version", "2023-07-01") - - if credential is None: - raise ValueError("Parameter 'credential' must not be None.") - if subscription_id is None: - raise ValueError("Parameter 'subscription_id' must not be None.") - - self.credential = credential - self.subscription_id = subscription_id - self.api_version = api_version - self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) - kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) - self.polling_interval = kwargs.get("polling_interval", 30) - self._configure(**kwargs) - - def _configure(self, **kwargs: Any) -> None: - 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.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**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) - self.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs) - self.authentication_policy = kwargs.get("authentication_policy") - if self.credential and not self.authentication_policy: - self.authentication_policy = ARMChallengeAuthenticationPolicy( - self.credential, *self.credential_scopes, **kwargs - ) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/_version.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/_version.py deleted file mode 100644 index 3b99a1418535..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/_version.py +++ /dev/null @@ -1,9 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -VERSION = "10.3.1" diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/__init__.py deleted file mode 100644 index 6ba0c5a05353..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/__init__.py +++ /dev/null @@ -1,23 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._key_vault_management_client import KeyVaultManagementClient - -try: - from ._patch import __all__ as _patch_all - from ._patch import * # pylint: disable=unused-wildcard-import -except ImportError: - _patch_all = [] -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "KeyVaultManagementClient", -] -__all__.extend([p for p in _patch_all if p not in __all__]) - -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_keys_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_keys_operations.py deleted file mode 100644 index 2624e2025992..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_keys_operations.py +++ /dev/null @@ -1,507 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, Type, TypeVar, Union, overload -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._keys_operations import ( - build_create_if_not_exist_request, - build_get_request, - build_get_version_request, - build_list_request, - build_list_versions_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class KeysOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2023_07_01.aio.KeyVaultManagementClient`'s - :attr:`keys` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @overload - async def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: _models.KeyCreateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. The value you provide may be copied - globally for the purpose of running the service. The value provided should not include - personally identifiable or sensitive information. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.KeyCreateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. The value you provide may be copied - globally for the purpose of running the service. The value provided should not include - personally identifiable or sensitive information. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: Union[_models.KeyCreateParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. The value you provide may be copied - globally for the purpose of running the service. The value provided should not include - personally identifiable or sensitive information. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Is either a - KeyCreateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.KeyCreateParameters or IO[bytes] - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "KeyCreateParameters") - - _request = build_create_if_not_exist_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def get(self, resource_group_name: str, vault_name: str, key_name: str, **kwargs: Any) -> _models.Key: - """Gets the current version of the specified key from the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key to be retrieved. Required. - :type vault_name: str - :param key_name: The name of the key to be retrieved. Required. - :type key_name: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> AsyncIterable["_models.Key"]: - """Lists the keys in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the keys to be retrieved. Required. - :type vault_name: str - :return: An iterator like instance of either Key or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.Key] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("KeyListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace_async - async def get_version( - self, resource_group_name: str, vault_name: str, key_name: str, key_version: str, **kwargs: Any - ) -> _models.Key: - """Gets the specified version of the specified key in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key version to be retrieved. - Required. - :type vault_name: str - :param key_name: The name of the key version to be retrieved. Required. - :type key_name: str - :param key_version: The version of the key to be retrieved. Required. - :type key_version: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - _request = build_get_version_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - key_version=key_version, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_versions( - self, resource_group_name: str, vault_name: str, key_name: str, **kwargs: Any - ) -> AsyncIterable["_models.Key"]: - """Lists the versions of the specified key in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key versions to be retrieved. - Required. - :type vault_name: str - :param key_name: The name of the key versions to be retrieved. Required. - :type key_name: str - :return: An iterator like instance of either Key or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.Key] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_versions_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("KeyListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_managed_hsms_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_managed_hsms_operations.py deleted file mode 100644 index 5ee61b04f44b..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_managed_hsms_operations.py +++ /dev/null @@ -1,1114 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._managed_hsms_operations import ( - build_check_mhsm_name_availability_request, - build_create_or_update_request, - build_delete_request, - build_get_deleted_request, - build_get_request, - build_list_by_resource_group_request, - build_list_by_subscription_request, - build_list_deleted_request, - build_purge_deleted_request, - build_update_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class ManagedHsmsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2023_07_01.aio.KeyVaultManagementClient`'s - :attr:`managed_hsms` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - async def _create_or_update_initial( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "ManagedHsm") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def begin_create_or_update( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Create or update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. Is either a ManagedHsm - type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm or IO[bytes] - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._create_or_update_initial( - resource_group_name=resource_group_name, - name=name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.ManagedHsm].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.ManagedHsm]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - async def _update_initial( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "ManagedHsm") - - _request = build_update_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @overload - async def begin_update( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_update( - self, - resource_group_name: str, - name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def begin_update( - self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any - ) -> AsyncLROPoller[_models.ManagedHsm]: - """Update a managed HSM Pool in the specified subscription. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :param parameters: Parameters to patch the managed HSM Pool. Is either a ManagedHsm type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm or IO[bytes] - :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of - cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._update_initial( - resource_group_name=resource_group_name, - name=name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.ManagedHsm].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.ManagedHsm]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - async def _delete_initial(self, resource_group_name: str, name: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_delete(self, resource_group_name: str, name: str, **kwargs: Any) -> AsyncLROPoller[None]: - """Deletes the specified managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: The name of the managed HSM Pool to delete. Required. - :type name: str - :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._delete_initial( - resource_group_name=resource_group_name, - name=name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace_async - async def get(self, resource_group_name: str, name: str, **kwargs: Any) -> Optional[_models.ManagedHsm]: - """Gets the specified managed HSM Pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: The name of the managed HSM Pool. Required. - :type name: str - :return: ManagedHsm or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm or None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[Optional[_models.ManagedHsm]] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: - deserialized = self._deserialize("ManagedHsm", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable["_models.ManagedHsm"]: - """The List operation gets information about the managed HSM Pools associated with the - subscription and within the specified resource group. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.ManagedHsm"]: - """The List operation gets information about the managed HSM Pools associated with the - subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either ManagedHsm or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedManagedHsm"]: - """The List operation gets information about the deleted managed HSMs associated with the - subscription. - - :return: An iterator like instance of either DeletedManagedHsm or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.DeletedManagedHsm] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.DeletedManagedHsmListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("DeletedManagedHsmListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace_async - async def get_deleted(self, name: str, location: str, **kwargs: Any) -> _models.DeletedManagedHsm: - """Gets the specified deleted managed HSM. - - :param name: The name of the deleted managed HSM. Required. - :type name: str - :param location: The location of the deleted managed HSM. Required. - :type location: str - :return: DeletedManagedHsm or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.DeletedManagedHsm - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.DeletedManagedHsm] = kwargs.pop("cls", None) - - _request = build_get_deleted_request( - name=name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - deserialized = self._deserialize("DeletedManagedHsm", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - async def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_purge_deleted_request( - name=name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_purge_deleted(self, name: str, location: str, **kwargs: Any) -> AsyncLROPoller[None]: - """Permanently deletes the specified managed HSM. - - :param name: The name of the soft-deleted managed HSM. Required. - :type name: str - :param location: The location of the soft-deleted managed HSM. Required. - :type location: str - :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._purge_deleted_initial( - name=name, - location=location, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @overload - async def check_mhsm_name_availability( - self, - mhsm_name: _models.CheckMhsmNameAvailabilityParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.CheckMhsmNameAvailabilityResult: - """Checks that the managed hsm name is valid and is not already in use. - - :param mhsm_name: The name of the managed hsm. Required. - :type mhsm_name: ~azure.mgmt.keyvault.v2023_07_01.models.CheckMhsmNameAvailabilityParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckMhsmNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.CheckMhsmNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def check_mhsm_name_availability( - self, mhsm_name: IO[bytes], *, content_type: str = "application/json", **kwargs: Any - ) -> _models.CheckMhsmNameAvailabilityResult: - """Checks that the managed hsm name is valid and is not already in use. - - :param mhsm_name: The name of the managed hsm. Required. - :type mhsm_name: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckMhsmNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.CheckMhsmNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def check_mhsm_name_availability( - self, mhsm_name: Union[_models.CheckMhsmNameAvailabilityParameters, IO[bytes]], **kwargs: Any - ) -> _models.CheckMhsmNameAvailabilityResult: - """Checks that the managed hsm name is valid and is not already in use. - - :param mhsm_name: The name of the managed hsm. Is either a CheckMhsmNameAvailabilityParameters - type or a IO[bytes] type. Required. - :type mhsm_name: ~azure.mgmt.keyvault.v2023_07_01.models.CheckMhsmNameAvailabilityParameters or - IO[bytes] - :return: CheckMhsmNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.CheckMhsmNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.CheckMhsmNameAvailabilityResult] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(mhsm_name, (IOBase, bytes)): - _content = mhsm_name - else: - _json = self._serialize.body(mhsm_name, "CheckMhsmNameAvailabilityParameters") - - _request = build_check_mhsm_name_availability_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("CheckMhsmNameAvailabilityResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_mhsm_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_mhsm_private_link_resources_operations.py deleted file mode 100644 index bcf59d1bc169..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_mhsm_private_link_resources_operations.py +++ /dev/null @@ -1,112 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._mhsm_private_link_resources_operations import build_list_by_mhsm_resource_request - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class MHSMPrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2023_07_01.aio.KeyVaultManagementClient`'s - :attr:`mhsm_private_link_resources` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace_async - async def list_by_mhsm_resource( - self, resource_group_name: str, name: str, **kwargs: Any - ) -> _models.MHSMPrivateLinkResourceListResult: - """Gets the private link resources supported for the managed hsm pool. - - :param resource_group_name: Name of the resource group that contains the managed HSM pool. - Required. - :type resource_group_name: str - :param name: Name of the managed HSM Pool. Required. - :type name: str - :return: MHSMPrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateLinkResourceListResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.MHSMPrivateLinkResourceListResult] = kwargs.pop("cls", None) - - _request = build_list_by_mhsm_resource_request( - resource_group_name=resource_group_name, - name=name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("MHSMPrivateLinkResourceListResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_operations.py deleted file mode 100644 index fb823e464576..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_operations.py +++ /dev/null @@ -1,131 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, AsyncIterable, Callable, Dict, Optional, Type, TypeVar -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._operations import build_list_request - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class Operations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2023_07_01.aio.KeyVaultManagementClient`'s - :attr:`operations` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: - """Lists all of the available Key Vault Rest API operations. - - :return: An iterator like instance of either Operation or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.Operation] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("OperationListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_patch.py deleted file mode 100644 index 9b4f32f151b7..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_patch.py +++ /dev/null @@ -1,136 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -import sys -from typing import AsyncIterable, Any, Optional, List, Type -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ._vaults_operations import VaultsOperations as _VaultsOperations, ClsType -from ...operations._vaults_operations import build_list_request - -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports - -class VaultsOperations(_VaultsOperations): - - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - -__all__: List[str] = ["VaultsOperations"] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_private_link_resources_operations.py deleted file mode 100644 index 15aba3e1a8be..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_private_link_resources_operations.py +++ /dev/null @@ -1,111 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ... import models as _models -from ...operations._private_link_resources_operations import build_list_by_vault_request - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class PrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2023_07_01.aio.KeyVaultManagementClient`'s - :attr:`private_link_resources` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace_async - async def list_by_vault( - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> _models.PrivateLinkResourceListResult: - """Gets the private link resources supported for the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :return: PrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.PrivateLinkResourceListResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.PrivateLinkResourceListResult] = kwargs.pop("cls", None) - - _request = build_list_by_vault_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_vaults_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_vaults_operations.py deleted file mode 100644 index e79f3577f704..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_vaults_operations.py +++ /dev/null @@ -1,1244 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import ( - Any, - AsyncIterable, - AsyncIterator, - Callable, - Dict, - IO, - Literal, - Optional, - Type, - TypeVar, - Union, - cast, - overload, -) -import urllib.parse - -from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling - -from ... import models as _models -from ...operations._vaults_operations import ( - build_check_name_availability_request, - build_create_or_update_request, - build_delete_request, - build_get_deleted_request, - build_get_request, - build_list_by_resource_group_request, - build_list_by_subscription_request, - build_list_deleted_request, - build_list_request, - build_purge_deleted_request, - build_update_access_policy_request, - build_update_request, -) - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - - -class VaultsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2023_07_01.aio.KeyVaultManagementClient`'s - :attr:`vaults` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - async def _create_or_update_initial( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 201: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.VaultCreateOrUpdateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2023_07_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2023_07_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> AsyncLROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Is either a - VaultCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.VaultCreateOrUpdateParameters or - IO[bytes] - :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2023_07_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._create_or_update_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("Vault", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.Vault].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.Vault]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @overload - async def update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultPatchParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.VaultPatchParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultPatchParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Is either a VaultPatchParameters type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.VaultPatchParameters or IO[bytes] - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultPatchParameters") - - _request = build_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def delete( # pylint: disable=inconsistent-return-statements - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> None: - """Deletes the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault to delete. Required. - :type vault_name: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - @distributed_trace_async - async def get(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> _models.Vault: - """Gets the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: _models.VaultAccessPolicyParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2023_07_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.VaultAccessPolicyParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2023_07_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: Union[_models.VaultAccessPolicyParameters, IO[bytes]], - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2023_07_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Is either a - VaultAccessPolicyParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.VaultAccessPolicyParameters or - IO[bytes] - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.VaultAccessPolicyParameters] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") - - _request = build_update_access_policy_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - operation_kind=operation_kind, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription and - within the specified resource group. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedVault"]: - """Gets information about the deleted vaults in a subscription. - - :return: An iterator like instance of either DeletedVault or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.DeletedVault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.DeletedVaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("DeletedVaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace_async - async def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _models.DeletedVault: - """Gets the deleted Azure key vault. - - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param location: The location of the deleted vault. Required. - :type location: str - :return: DeletedVault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.DeletedVault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.DeletedVault] = kwargs.pop("cls", None) - - _request = build_get_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("DeletedVault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - async def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_purge_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_purge_deleted(self, vault_name: str, location: str, **kwargs: Any) -> AsyncLROPoller[None]: - """Permanently deletes the specified vault. aka Purges the deleted Azure key vault. - - :param vault_name: The name of the soft-deleted vault. Required. - :type vault_name: str - :param location: The location of the soft-deleted vault. Required. - :type location: str - :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._purge_deleted_initial( - vault_name=vault_name, - location=location, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - async def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @overload - async def check_name_availability( - self, - vault_name: _models.VaultCheckNameAvailabilityParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: ~azure.mgmt.keyvault.v2023_07_01.models.VaultCheckNameAvailabilityParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def check_name_availability( - self, vault_name: IO[bytes], *, content_type: str = "application/json", **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def check_name_availability( - self, vault_name: Union[_models.VaultCheckNameAvailabilityParameters, IO[bytes]], **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Is either a VaultCheckNameAvailabilityParameters type - or a IO[bytes] type. Required. - :type vault_name: ~azure.mgmt.keyvault.v2023_07_01.models.VaultCheckNameAvailabilityParameters - or IO[bytes] - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.CheckNameAvailabilityResult] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(vault_name, (IOBase, bytes)): - _content = vault_name - else: - _json = self._serialize.body(vault_name, "VaultCheckNameAvailabilityParameters") - - _request = build_check_name_availability_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/models/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/models/__init__.py deleted file mode 100644 index 18597b59b436..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/models/__init__.py +++ /dev/null @@ -1,263 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from ._models_py3 import AccessPolicyEntry -from ._models_py3 import Action -from ._models_py3 import Attributes -from ._models_py3 import CheckMhsmNameAvailabilityParameters -from ._models_py3 import CheckMhsmNameAvailabilityResult -from ._models_py3 import CheckNameAvailabilityResult -from ._models_py3 import CloudErrorBody -from ._models_py3 import DeletedManagedHsm -from ._models_py3 import DeletedManagedHsmListResult -from ._models_py3 import DeletedManagedHsmProperties -from ._models_py3 import DeletedVault -from ._models_py3 import DeletedVaultListResult -from ._models_py3 import DeletedVaultProperties -from ._models_py3 import DimensionProperties -from ._models_py3 import Error -from ._models_py3 import IPRule -from ._models_py3 import Key -from ._models_py3 import KeyAttributes -from ._models_py3 import KeyCreateParameters -from ._models_py3 import KeyListResult -from ._models_py3 import KeyProperties -from ._models_py3 import KeyReleasePolicy -from ._models_py3 import KeyRotationPolicyAttributes -from ._models_py3 import LifetimeAction -from ._models_py3 import LogSpecification -from ._models_py3 import MHSMGeoReplicatedRegion -from ._models_py3 import MHSMIPRule -from ._models_py3 import MHSMNetworkRuleSet -from ._models_py3 import MHSMPrivateEndpoint -from ._models_py3 import MHSMPrivateEndpointConnection -from ._models_py3 import MHSMPrivateEndpointConnectionItem -from ._models_py3 import MHSMPrivateEndpointConnectionsListResult -from ._models_py3 import MHSMPrivateLinkResource -from ._models_py3 import MHSMPrivateLinkResourceListResult -from ._models_py3 import MHSMPrivateLinkServiceConnectionState -from ._models_py3 import MHSMRegionsListResult -from ._models_py3 import MHSMVirtualNetworkRule -from ._models_py3 import ManagedHSMSecurityDomainProperties -from ._models_py3 import ManagedHsm -from ._models_py3 import ManagedHsmAction -from ._models_py3 import ManagedHsmError -from ._models_py3 import ManagedHsmKey -from ._models_py3 import ManagedHsmKeyAttributes -from ._models_py3 import ManagedHsmKeyCreateParameters -from ._models_py3 import ManagedHsmKeyListResult -from ._models_py3 import ManagedHsmKeyProperties -from ._models_py3 import ManagedHsmKeyReleasePolicy -from ._models_py3 import ManagedHsmKeyRotationPolicyAttributes -from ._models_py3 import ManagedHsmLifetimeAction -from ._models_py3 import ManagedHsmListResult -from ._models_py3 import ManagedHsmProperties -from ._models_py3 import ManagedHsmResource -from ._models_py3 import ManagedHsmRotationPolicy -from ._models_py3 import ManagedHsmSku -from ._models_py3 import ManagedHsmTrigger -from ._models_py3 import ManagedServiceIdentity -from ._models_py3 import MetricSpecification -from ._models_py3 import NetworkRuleSet -from ._models_py3 import Operation -from ._models_py3 import OperationDisplay -from ._models_py3 import OperationListResult -from ._models_py3 import Permissions -from ._models_py3 import PrivateEndpoint -from ._models_py3 import PrivateEndpointConnection -from ._models_py3 import PrivateEndpointConnectionItem -from ._models_py3 import PrivateEndpointConnectionListResult -from ._models_py3 import PrivateLinkResource -from ._models_py3 import PrivateLinkResourceListResult -from ._models_py3 import PrivateLinkServiceConnectionState -from ._models_py3 import ProxyResourceWithoutSystemData -from ._models_py3 import Resource -from ._models_py3 import ResourceListResult -from ._models_py3 import RotationPolicy -from ._models_py3 import Secret -from ._models_py3 import SecretAttributes -from ._models_py3 import SecretCreateOrUpdateParameters -from ._models_py3 import SecretListResult -from ._models_py3 import SecretPatchParameters -from ._models_py3 import SecretPatchProperties -from ._models_py3 import SecretProperties -from ._models_py3 import ServiceSpecification -from ._models_py3 import Sku -from ._models_py3 import SystemData -from ._models_py3 import Trigger -from ._models_py3 import UserAssignedIdentity -from ._models_py3 import Vault -from ._models_py3 import VaultAccessPolicyParameters -from ._models_py3 import VaultAccessPolicyProperties -from ._models_py3 import VaultCheckNameAvailabilityParameters -from ._models_py3 import VaultCreateOrUpdateParameters -from ._models_py3 import VaultListResult -from ._models_py3 import VaultPatchParameters -from ._models_py3 import VaultPatchProperties -from ._models_py3 import VaultProperties -from ._models_py3 import VirtualNetworkRule - -from ._key_vault_management_client_enums import AccessPolicyUpdateKind -from ._key_vault_management_client_enums import ActionsRequired -from ._key_vault_management_client_enums import ActivationStatus -from ._key_vault_management_client_enums import CertificatePermissions -from ._key_vault_management_client_enums import CreateMode -from ._key_vault_management_client_enums import DeletionRecoveryLevel -from ._key_vault_management_client_enums import GeoReplicationRegionProvisioningState -from ._key_vault_management_client_enums import IdentityType -from ._key_vault_management_client_enums import JsonWebKeyCurveName -from ._key_vault_management_client_enums import JsonWebKeyOperation -from ._key_vault_management_client_enums import JsonWebKeyType -from ._key_vault_management_client_enums import KeyPermissions -from ._key_vault_management_client_enums import KeyRotationPolicyActionType -from ._key_vault_management_client_enums import ManagedHsmSkuFamily -from ._key_vault_management_client_enums import ManagedHsmSkuName -from ._key_vault_management_client_enums import ManagedServiceIdentityType -from ._key_vault_management_client_enums import NetworkRuleAction -from ._key_vault_management_client_enums import NetworkRuleBypassOptions -from ._key_vault_management_client_enums import PrivateEndpointConnectionProvisioningState -from ._key_vault_management_client_enums import PrivateEndpointServiceConnectionStatus -from ._key_vault_management_client_enums import ProvisioningState -from ._key_vault_management_client_enums import PublicNetworkAccess -from ._key_vault_management_client_enums import Reason -from ._key_vault_management_client_enums import SecretPermissions -from ._key_vault_management_client_enums import SkuFamily -from ._key_vault_management_client_enums import SkuName -from ._key_vault_management_client_enums import StoragePermissions -from ._key_vault_management_client_enums import VaultProvisioningState -from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - -__all__ = [ - "AccessPolicyEntry", - "Action", - "Attributes", - "CheckMhsmNameAvailabilityParameters", - "CheckMhsmNameAvailabilityResult", - "CheckNameAvailabilityResult", - "CloudErrorBody", - "DeletedManagedHsm", - "DeletedManagedHsmListResult", - "DeletedManagedHsmProperties", - "DeletedVault", - "DeletedVaultListResult", - "DeletedVaultProperties", - "DimensionProperties", - "Error", - "IPRule", - "Key", - "KeyAttributes", - "KeyCreateParameters", - "KeyListResult", - "KeyProperties", - "KeyReleasePolicy", - "KeyRotationPolicyAttributes", - "LifetimeAction", - "LogSpecification", - "MHSMGeoReplicatedRegion", - "MHSMIPRule", - "MHSMNetworkRuleSet", - "MHSMPrivateEndpoint", - "MHSMPrivateEndpointConnection", - "MHSMPrivateEndpointConnectionItem", - "MHSMPrivateEndpointConnectionsListResult", - "MHSMPrivateLinkResource", - "MHSMPrivateLinkResourceListResult", - "MHSMPrivateLinkServiceConnectionState", - "MHSMRegionsListResult", - "MHSMVirtualNetworkRule", - "ManagedHSMSecurityDomainProperties", - "ManagedHsm", - "ManagedHsmAction", - "ManagedHsmError", - "ManagedHsmKey", - "ManagedHsmKeyAttributes", - "ManagedHsmKeyCreateParameters", - "ManagedHsmKeyListResult", - "ManagedHsmKeyProperties", - "ManagedHsmKeyReleasePolicy", - "ManagedHsmKeyRotationPolicyAttributes", - "ManagedHsmLifetimeAction", - "ManagedHsmListResult", - "ManagedHsmProperties", - "ManagedHsmResource", - "ManagedHsmRotationPolicy", - "ManagedHsmSku", - "ManagedHsmTrigger", - "ManagedServiceIdentity", - "MetricSpecification", - "NetworkRuleSet", - "Operation", - "OperationDisplay", - "OperationListResult", - "Permissions", - "PrivateEndpoint", - "PrivateEndpointConnection", - "PrivateEndpointConnectionItem", - "PrivateEndpointConnectionListResult", - "PrivateLinkResource", - "PrivateLinkResourceListResult", - "PrivateLinkServiceConnectionState", - "ProxyResourceWithoutSystemData", - "Resource", - "ResourceListResult", - "RotationPolicy", - "Secret", - "SecretAttributes", - "SecretCreateOrUpdateParameters", - "SecretListResult", - "SecretPatchParameters", - "SecretPatchProperties", - "SecretProperties", - "ServiceSpecification", - "Sku", - "SystemData", - "Trigger", - "UserAssignedIdentity", - "Vault", - "VaultAccessPolicyParameters", - "VaultAccessPolicyProperties", - "VaultCheckNameAvailabilityParameters", - "VaultCreateOrUpdateParameters", - "VaultListResult", - "VaultPatchParameters", - "VaultPatchProperties", - "VaultProperties", - "VirtualNetworkRule", - "AccessPolicyUpdateKind", - "ActionsRequired", - "ActivationStatus", - "CertificatePermissions", - "CreateMode", - "DeletionRecoveryLevel", - "GeoReplicationRegionProvisioningState", - "IdentityType", - "JsonWebKeyCurveName", - "JsonWebKeyOperation", - "JsonWebKeyType", - "KeyPermissions", - "KeyRotationPolicyActionType", - "ManagedHsmSkuFamily", - "ManagedHsmSkuName", - "ManagedServiceIdentityType", - "NetworkRuleAction", - "NetworkRuleBypassOptions", - "PrivateEndpointConnectionProvisioningState", - "PrivateEndpointServiceConnectionStatus", - "ProvisioningState", - "PublicNetworkAccess", - "Reason", - "SecretPermissions", - "SkuFamily", - "SkuName", - "StoragePermissions", - "VaultProvisioningState", -] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/models/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/models/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/models/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_keys_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_keys_operations.py deleted file mode 100644 index 8bb70ef3a986..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_keys_operations.py +++ /dev/null @@ -1,664 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Optional, Type, TypeVar, Union, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_if_not_exist_request( - resource_group_name: str, vault_name: str, key_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "keyName": _SERIALIZER.url("key_name", key_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request( - resource_group_name: str, vault_name: str, key_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "keyName": _SERIALIZER.url("key_name", key_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_version_request( - resource_group_name: str, vault_name: str, key_name: str, key_version: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "keyName": _SERIALIZER.url("key_name", key_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - "keyVersion": _SERIALIZER.url("key_version", key_version, "str", pattern=r"^[a-fA-F0-9]{32}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_versions_request( - resource_group_name: str, vault_name: str, key_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "keyName": _SERIALIZER.url("key_name", key_name, "str", pattern=r"^[a-zA-Z0-9-]{1,127}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class KeysOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2023_07_01.KeyVaultManagementClient`'s - :attr:`keys` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @overload - def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: _models.KeyCreateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. The value you provide may be copied - globally for the purpose of running the service. The value provided should not include - personally identifiable or sensitive information. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.KeyCreateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. The value you provide may be copied - globally for the purpose of running the service. The value provided should not include - personally identifiable or sensitive information. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def create_if_not_exist( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - parameters: Union[_models.KeyCreateParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Key: - """Creates the first version of a new key if it does not exist. If it already exists, then the - existing key is returned without any write operations being performed. This API does not create - subsequent versions, and does not update existing keys. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. Required. - :type vault_name: str - :param key_name: The name of the key to be created. The value you provide may be copied - globally for the purpose of running the service. The value provided should not include - personally identifiable or sensitive information. Required. - :type key_name: str - :param parameters: The parameters used to create the specified key. Is either a - KeyCreateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.KeyCreateParameters or IO[bytes] - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "KeyCreateParameters") - - _request = build_create_if_not_exist_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def get(self, resource_group_name: str, vault_name: str, key_name: str, **kwargs: Any) -> _models.Key: - """Gets the current version of the specified key from the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key to be retrieved. Required. - :type vault_name: str - :param key_name: The name of the key to be retrieved. Required. - :type key_name: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> Iterable["_models.Key"]: - """Lists the keys in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the keys to be retrieved. Required. - :type vault_name: str - :return: An iterator like instance of either Key or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.Key] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("KeyListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def get_version( - self, resource_group_name: str, vault_name: str, key_name: str, key_version: str, **kwargs: Any - ) -> _models.Key: - """Gets the specified version of the specified key in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key version to be retrieved. - Required. - :type vault_name: str - :param key_name: The name of the key version to be retrieved. Required. - :type key_name: str - :param key_version: The version of the key to be retrieved. Required. - :type key_version: str - :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Key - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.Key] = kwargs.pop("cls", None) - - _request = build_get_version_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - key_version=key_version, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Key", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_versions( - self, resource_group_name: str, vault_name: str, key_name: str, **kwargs: Any - ) -> Iterable["_models.Key"]: - """Lists the versions of the specified key in the specified key vault. - - :param resource_group_name: The name of the resource group which contains the specified key - vault. Required. - :type resource_group_name: str - :param vault_name: The name of the vault which contains the key versions to be retrieved. - Required. - :type vault_name: str - :param key_name: The name of the key versions to be retrieved. Required. - :type key_name: str - :return: An iterator like instance of either Key or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.Key] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_versions_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("KeyListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_operations.py deleted file mode 100644 index 6b8ae4259517..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_operations.py +++ /dev/null @@ -1,152 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Iterable, Optional, Type, TypeVar -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_request(**kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/providers/Microsoft.KeyVault/operations") - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class Operations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2023_07_01.KeyVaultManagementClient`'s - :attr:`operations` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: - """Lists all of the available Key Vault Rest API operations. - - :return: An iterator like instance of either Operation or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.Operation] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("OperationListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_patch.py deleted file mode 100644 index 944d9d4d8c8f..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_patch.py +++ /dev/null @@ -1,134 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -import sys -from typing import Any, List, Iterable, Optional, Type -import urllib.parse - -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.rest import HttpRequest -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.mgmt.core.exceptions import ARMErrorFormat - -from ._vaults_operations import VaultsOperations as _VaultsOperations, ClsType, build_list_request -from .. import models as _models - -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports - -class VaultsOperations(_VaultsOperations): - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - -__all__: List[str] = ["VaultsOperations"] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_private_endpoint_connections_operations.py deleted file mode 100644 index 56c8937d8b4a..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_private_endpoint_connections_operations.py +++ /dev/null @@ -1,627 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_get_request( - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_put_request( - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request( - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "privateEndpointConnectionName": _SERIALIZER.url( - "private_endpoint_connection_name", private_endpoint_connection_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_resource_request( - resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class PrivateEndpointConnectionsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2023_07_01.KeyVaultManagementClient`'s - :attr:`private_endpoint_connections` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def get( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Optional[_models.PrivateEndpointConnection]: - """Gets the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: PrivateEndpointConnection or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnection or None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[Optional[_models.PrivateEndpointConnection]] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: _models.PrivateEndpointConnection, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnection - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def put( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - properties: Union[_models.PrivateEndpointConnection, IO[bytes]], - **kwargs: Any - ) -> _models.PrivateEndpointConnection: - """Updates the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. Is either a - PrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnection or - IO[bytes] - :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnection - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _json = self._serialize.body(properties, "PrivateEndpointConnection") - - _request = build_put_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Azure-AsyncOperation"] = self._deserialize( - "str", response.headers.get("Azure-AsyncOperation") - ) - - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - def _delete_initial( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202, 204]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_delete( - self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any - ) -> LROPoller[_models.PrivateEndpointConnection]: - """Deletes the specified private endpoint connection associated with the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :param private_endpoint_connection_name: Name of the private endpoint connection associated - with the key vault. Required. - :type private_endpoint_connection_name: str - :return: An instance of LROPoller that returns either PrivateEndpointConnection or the result - of cls(response) - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._delete_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - private_endpoint_connection_name=private_endpoint_connection_name, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.PrivateEndpointConnection].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.PrivateEndpointConnection]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @distributed_trace - def list_by_resource( - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> Iterable["_models.PrivateEndpointConnection"]: - """The List operation gets information about the private endpoint connections associated with the - vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :return: An iterator like instance of either PrivateEndpointConnection or the result of - cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnection] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.PrivateEndpointConnectionListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("PrivateEndpointConnectionListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_private_link_resources_operations.py deleted file mode 100644 index a17c97c2ccd6..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_private_link_resources_operations.py +++ /dev/null @@ -1,145 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_by_vault_request( - resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources", - ) # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class PrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2023_07_01.KeyVaultManagementClient`'s - :attr:`private_link_resources` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - @distributed_trace - def list_by_vault( - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> _models.PrivateLinkResourceListResult: - """Gets the private link resources supported for the key vault. - - :param resource_group_name: Name of the resource group that contains the key vault. Required. - :type resource_group_name: str - :param vault_name: The name of the key vault. Required. - :type vault_name: str - :return: PrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.PrivateLinkResourceListResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.PrivateLinkResourceListResult] = kwargs.pop("cls", None) - - _request = build_list_by_vault_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_vaults_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_vaults_operations.py deleted file mode 100644 index 3b0f81eb790b..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_vaults_operations.py +++ /dev/null @@ -1,1581 +0,0 @@ -# pylint: disable=too-many-lines,too-many-statements -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from io import IOBase -import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Literal, Optional, Type, TypeVar, Union, cast, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.paging import ItemPaged -from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict -from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling - -from .. import models as _models -from ..._serialization import Serializer - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_or_update_request( - resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_request(resource_group_name: str, vault_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_access_policy_request( - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str", pattern=r"^[a-zA-Z0-9-]{3,24}$"), - "operationKind": _SERIALIZER.url("operation_kind", operation_kind, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_resource_group_request( - resource_group_name: str, subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults", - ) # pylint: disable=line-too-long - path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_by_subscription_request( - subscription_id: str, *, top: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_deleted_request(subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_deleted_request(vault_name: str, location: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}", - ) # pylint: disable=line-too-long - path_format_arguments = { - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "location": _SERIALIZER.url("location", location, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_purge_deleted_request(vault_name: str, location: str, subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", - "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge", - ) # pylint: disable=line-too-long - path_format_arguments = { - "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), - "location": _SERIALIZER.url("location", location, "str"), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_request(subscription_id: str, *, top: Optional[int] = None, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop("api_version", _params.pop("api-version", "2015-11-01")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resources") - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["$filter"] = _SERIALIZER.query("filter", filter, "str") - if top is not None: - _params["$top"] = _SERIALIZER.query("top", top, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_check_name_availability_request(subscription_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop( - "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability" - ) - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -class VaultsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2023_07_01.KeyVaultManagementClient`'s - :attr:`vaults` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version") - - def _create_or_update_initial( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - - _request = build_create_or_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 201: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.VaultCreateOrUpdateParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2023_07_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2023_07_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def begin_create_or_update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], - **kwargs: Any - ) -> LROPoller[_models.Vault]: - """Create or update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to create or update the vault. Is either a - VaultCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.VaultCreateOrUpdateParameters or - IO[bytes] - :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2023_07_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._create_or_update_initial( - resource_group_name=resource_group_name, - vault_name=vault_name, - parameters=parameters, - api_version=api_version, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - deserialized = self._deserialize("Vault", pipeline_response.http_response) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.Vault].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.Vault]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @overload - def update( - self, - resource_group_name: str, - vault_name: str, - parameters: _models.VaultPatchParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.VaultPatchParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def update( - self, - resource_group_name: str, - vault_name: str, - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def update( - self, - resource_group_name: str, - vault_name: str, - parameters: Union[_models.VaultPatchParameters, IO[bytes]], - **kwargs: Any - ) -> _models.Vault: - """Update a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the server belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param parameters: Parameters to patch the vault. Is either a VaultPatchParameters type or a - IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.VaultPatchParameters or IO[bytes] - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultPatchParameters") - - _request = build_update_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def delete( # pylint: disable=inconsistent-return-statements - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> None: - """Deletes the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault to delete. Required. - :type vault_name: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_delete_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - @distributed_trace - def get(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> _models.Vault: - """Gets the specified Azure key vault. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: The name of the vault. Required. - :type vault_name: str - :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Vault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.Vault] = kwargs.pop("cls", None) - - _request = build_get_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: _models.VaultAccessPolicyParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2023_07_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.VaultAccessPolicyParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2023_07_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Required. - :type parameters: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def update_access_policy( - self, - resource_group_name: str, - vault_name: str, - operation_kind: Union[str, _models.AccessPolicyUpdateKind], - parameters: Union[_models.VaultAccessPolicyParameters, IO[bytes]], - **kwargs: Any - ) -> _models.VaultAccessPolicyParameters: - """Update access policies in a key vault in the specified subscription. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param vault_name: Name of the vault. Required. - :type vault_name: str - :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". - Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2023_07_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. Is either a - VaultAccessPolicyParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.VaultAccessPolicyParameters or - IO[bytes] - :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.VaultAccessPolicyParameters - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.VaultAccessPolicyParameters] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") - - _request = build_update_access_policy_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - operation_kind=operation_kind, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_by_resource_group( - self, resource_group_name: str, top: Optional[int] = None, **kwargs: Any - ) -> Iterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription and - within the specified resource group. - - :param resource_group_name: The name of the Resource Group to which the vault belongs. - Required. - :type resource_group_name: str - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Vault"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.Vault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - top=top, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("VaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedVault"]: - """Gets information about the deleted vaults in a subscription. - - :return: An iterator like instance of either DeletedVault or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.DeletedVault] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.DeletedVaultListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("DeletedVaultListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _models.DeletedVault: - """Gets the deleted Azure key vault. - - :param vault_name: The name of the vault. Required. - :type vault_name: str - :param location: The location of the deleted vault. Required. - :type location: str - :return: DeletedVault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.DeletedVault - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[_models.DeletedVault] = kwargs.pop("cls", None) - - _request = build_get_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("DeletedVault", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_purge_deleted_request( - vault_name=vault_name, - location=location, - subscription_id=self._config.subscription_id, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_purge_deleted(self, vault_name: str, location: str, **kwargs: Any) -> LROPoller[None]: - """Permanently deletes the specified vault. aka Purges the deleted Azure key vault. - - :param vault_name: The name of the soft-deleted vault. Required. - :type vault_name: str - :param location: The location of the soft-deleted vault. Required. - :type location: str - :return: An instance of LROPoller that returns either None or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._purge_deleted_initial( - vault_name=vault_name, - location=location, - api_version=api_version, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - if polling is True: - polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Resource"]: - """The List operation gets information about the vaults associated with the subscription. - - :param top: Maximum number of results to return. Default value is None. - :type top: int - :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.Resource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - filter: Literal["resourceType eq 'Microsoft.KeyVault/vaults'"] = kwargs.pop( - "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") - ) - api_version: Literal["2015-11-01"] = kwargs.pop( - "api_version", _params.pop("api-version", self._api_version or "2015-11-01") - ) - cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_list_request( - subscription_id=self._config.subscription_id, - top=top, - filter=filter, - api_version=api_version, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - _request.url = self._client.format_url(_request.url) - _request.method = "GET" - return _request - - def extract_data(pipeline_response): - deserialized = self._deserialize("ResourceListResult", pipeline_response) - list_of_elem = deserialized.value - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.next_link or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @overload - def check_name_availability( - self, - vault_name: _models.VaultCheckNameAvailabilityParameters, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: ~azure.mgmt.keyvault.v2023_07_01.models.VaultCheckNameAvailabilityParameters - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def check_name_availability( - self, vault_name: IO[bytes], *, content_type: str = "application/json", **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Required. - :type vault_name: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def check_name_availability( - self, vault_name: Union[_models.VaultCheckNameAvailabilityParameters, IO[bytes]], **kwargs: Any - ) -> _models.CheckNameAvailabilityResult: - """Checks that the vault name is valid and is not already in use. - - :param vault_name: The name of the vault. Is either a VaultCheckNameAvailabilityParameters type - or a IO[bytes] type. Required. - :type vault_name: ~azure.mgmt.keyvault.v2023_07_01.models.VaultCheckNameAvailabilityParameters - or IO[bytes] - :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.CheckNameAvailabilityResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.CheckNameAvailabilityResult] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(vault_name, (IOBase, bytes)): - _content = vault_name - else: - _json = self._serialize.body(vault_name, "VaultCheckNameAvailabilityParameters") - - _request = build_check_name_availability_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/py.typed b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/py.typed deleted file mode 100644 index e5aff4f83af8..000000000000 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/py.typed +++ /dev/null @@ -1 +0,0 @@ -# Marker file for PEP 561. \ No newline at end of file diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/__init__.py similarity index 79% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/__init__.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/__init__.py index 6bb4b7c63a45..a60631755701 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/__init__.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/__init__.py @@ -5,15 +5,21 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +# pylint: disable=wrong-import-position -from ._key_vault_management_client import KeyVaultManagementClient +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._key_vault_management_client import KeyVaultManagementClient # type: ignore from ._version import VERSION __version__ = VERSION try: from ._patch import __all__ as _patch_all - from ._patch import * # pylint: disable=unused-wildcard-import + from ._patch import * except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk @@ -21,6 +27,6 @@ __all__ = [ "KeyVaultManagementClient", ] -__all__.extend([p for p in _patch_all if p not in __all__]) +__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/_configuration.py similarity index 93% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/_configuration.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/_configuration.py index 01a34d3114d6..f35fc3a9f7b2 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/_configuration.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/_configuration.py @@ -14,11 +14,10 @@ from ._version import VERSION if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials import TokenCredential -class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long +class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes """Configuration for KeyVaultManagementClient. Note that all parameters used to create this instance are saved as instance @@ -29,13 +28,13 @@ class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instanc :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. Required. :type subscription_id: str - :keyword api_version: Api Version. Default value is "2021-10-01". Note that overriding this + :keyword api_version: Api Version. Default value is "2024-11-01". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None: - api_version: str = kwargs.pop("api_version", "2021-10-01") + api_version: str = kwargs.pop("api_version", "2024-11-01") if credential is None: raise ValueError("Parameter 'credential' must not be None.") diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/_key_vault_management_client.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/_key_vault_management_client.py similarity index 85% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/_key_vault_management_client.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/_key_vault_management_client.py index 4aac36e62ace..e3c9469e19c9 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/_key_vault_management_client.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/_key_vault_management_client.py @@ -33,40 +33,39 @@ ) if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials import TokenCredential -class KeyVaultManagementClient: # pylint: disable=client-accepts-api-version-keyword,too-many-instance-attributes +class KeyVaultManagementClient: # pylint: disable=too-many-instance-attributes """The Azure management API provides a RESTful set of web services that interact with Azure Key Vault. :ivar keys: KeysOperations operations - :vartype keys: azure.mgmt.keyvault.v2023_07_01.operations.KeysOperations + :vartype keys: azure.mgmt.keyvault.v2024_11_01.operations.KeysOperations :ivar managed_hsm_keys: ManagedHsmKeysOperations operations - :vartype managed_hsm_keys: azure.mgmt.keyvault.v2023_07_01.operations.ManagedHsmKeysOperations + :vartype managed_hsm_keys: azure.mgmt.keyvault.v2024_11_01.operations.ManagedHsmKeysOperations :ivar vaults: VaultsOperations operations - :vartype vaults: azure.mgmt.keyvault.v2023_07_01.operations.VaultsOperations + :vartype vaults: azure.mgmt.keyvault.v2024_11_01.operations.VaultsOperations :ivar private_endpoint_connections: PrivateEndpointConnectionsOperations operations :vartype private_endpoint_connections: - azure.mgmt.keyvault.v2023_07_01.operations.PrivateEndpointConnectionsOperations + azure.mgmt.keyvault.v2024_11_01.operations.PrivateEndpointConnectionsOperations :ivar private_link_resources: PrivateLinkResourcesOperations operations :vartype private_link_resources: - azure.mgmt.keyvault.v2023_07_01.operations.PrivateLinkResourcesOperations + azure.mgmt.keyvault.v2024_11_01.operations.PrivateLinkResourcesOperations :ivar managed_hsms: ManagedHsmsOperations operations - :vartype managed_hsms: azure.mgmt.keyvault.v2023_07_01.operations.ManagedHsmsOperations + :vartype managed_hsms: azure.mgmt.keyvault.v2024_11_01.operations.ManagedHsmsOperations :ivar mhsm_private_endpoint_connections: MHSMPrivateEndpointConnectionsOperations operations :vartype mhsm_private_endpoint_connections: - azure.mgmt.keyvault.v2023_07_01.operations.MHSMPrivateEndpointConnectionsOperations + azure.mgmt.keyvault.v2024_11_01.operations.MHSMPrivateEndpointConnectionsOperations :ivar mhsm_private_link_resources: MHSMPrivateLinkResourcesOperations operations :vartype mhsm_private_link_resources: - azure.mgmt.keyvault.v2023_07_01.operations.MHSMPrivateLinkResourcesOperations + azure.mgmt.keyvault.v2024_11_01.operations.MHSMPrivateLinkResourcesOperations :ivar mhsm_regions: MHSMRegionsOperations operations - :vartype mhsm_regions: azure.mgmt.keyvault.v2023_07_01.operations.MHSMRegionsOperations + :vartype mhsm_regions: azure.mgmt.keyvault.v2024_11_01.operations.MHSMRegionsOperations :ivar operations: Operations operations - :vartype operations: azure.mgmt.keyvault.v2023_07_01.operations.Operations + :vartype operations: azure.mgmt.keyvault.v2024_11_01.operations.Operations :ivar secrets: SecretsOperations operations - :vartype secrets: azure.mgmt.keyvault.v2023_07_01.operations.SecretsOperations + :vartype secrets: azure.mgmt.keyvault.v2024_11_01.operations.SecretsOperations :param credential: Credential needed for the client to connect to Azure. Required. :type credential: ~azure.core.credentials.TokenCredential :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure @@ -74,7 +73,7 @@ class KeyVaultManagementClient: # pylint: disable=client-accepts-api-version-ke :type subscription_id: str :param base_url: Service URL. Default value is "https://management.azure.com". :type base_url: str - :keyword api_version: Api Version. Default value is "2023-07-01". Note that overriding this + :keyword api_version: Api Version. Default value is "2024-11-01". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str :keyword int polling_interval: Default waiting time between two polls for LRO operations if no @@ -115,31 +114,31 @@ def __init__( self._serialize = Serializer(client_models) self._deserialize = Deserializer(client_models) self._serialize.client_side_validation = False - self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize, "2023-07-01") + self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize, "2024-11-01") self.managed_hsm_keys = ManagedHsmKeysOperations( - self._client, self._config, self._serialize, self._deserialize, "2023-07-01" + self._client, self._config, self._serialize, self._deserialize, "2024-11-01" ) - self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize, "2023-07-01") + self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize, "2024-11-01") self.private_endpoint_connections = PrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2023-07-01" + self._client, self._config, self._serialize, self._deserialize, "2024-11-01" ) self.private_link_resources = PrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2023-07-01" + self._client, self._config, self._serialize, self._deserialize, "2024-11-01" ) self.managed_hsms = ManagedHsmsOperations( - self._client, self._config, self._serialize, self._deserialize, "2023-07-01" + self._client, self._config, self._serialize, self._deserialize, "2024-11-01" ) self.mhsm_private_endpoint_connections = MHSMPrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2023-07-01" + self._client, self._config, self._serialize, self._deserialize, "2024-11-01" ) self.mhsm_private_link_resources = MHSMPrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2023-07-01" + self._client, self._config, self._serialize, self._deserialize, "2024-11-01" ) self.mhsm_regions = MHSMRegionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2023-07-01" + self._client, self._config, self._serialize, self._deserialize, "2024-11-01" ) - self.operations = Operations(self._client, self._config, self._serialize, self._deserialize, "2023-07-01") - self.secrets = SecretsOperations(self._client, self._config, self._serialize, self._deserialize, "2023-07-01") + self.operations = Operations(self._client, self._config, self._serialize, self._deserialize, "2024-11-01") + self.secrets = SecretsOperations(self._client, self._config, self._serialize, self._deserialize, "2024-11-01") def _send_request(self, request: HttpRequest, *, stream: bool = False, **kwargs: Any) -> HttpResponse: """Runs the network request through the client's chained policies. diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/_metadata.json b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/_metadata.json similarity index 98% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/_metadata.json rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/_metadata.json index 8e242f71699f..6bc35ca73228 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/_metadata.json +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/_metadata.json @@ -1,6 +1,6 @@ { - "chosen_version": "2023-07-01", - "total_api_version_list": ["2023-07-01"], + "chosen_version": "2024-11-01", + "total_api_version_list": ["2024-11-01"], "client": { "name": "KeyVaultManagementClient", "filename": "_key_vault_management_client", diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/_patch.py similarity index 100% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/_patch.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/_patch.py diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/_version.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/_version.py similarity index 95% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/_version.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/_version.py index 3b99a1418535..e5754a47ce68 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/_version.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/_version.py @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "10.3.1" +VERSION = "1.0.0b1" diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/__init__.py similarity index 78% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/__init__.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/__init__.py index 6bb4b7c63a45..30acffb8c4a7 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/__init__.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/__init__.py @@ -5,15 +5,18 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +# pylint: disable=wrong-import-position -from ._key_vault_management_client import KeyVaultManagementClient -from ._version import VERSION +from typing import TYPE_CHECKING -__version__ = VERSION +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._key_vault_management_client import KeyVaultManagementClient # type: ignore try: from ._patch import __all__ as _patch_all - from ._patch import * # pylint: disable=unused-wildcard-import + from ._patch import * except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk @@ -21,6 +24,6 @@ __all__ = [ "KeyVaultManagementClient", ] -__all__.extend([p for p in _patch_all if p not in __all__]) +__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/_configuration.py similarity index 93% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/_configuration.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/_configuration.py index f2d369cf48d8..c545da022550 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/_configuration.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/_configuration.py @@ -14,11 +14,10 @@ from .._version import VERSION if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials_async import AsyncTokenCredential -class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long +class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instance-attributes """Configuration for KeyVaultManagementClient. Note that all parameters used to create this instance are saved as instance @@ -29,13 +28,13 @@ class KeyVaultManagementClientConfiguration: # pylint: disable=too-many-instanc :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. Required. :type subscription_id: str - :keyword api_version: Api Version. Default value is "2023-07-01". Note that overriding this + :keyword api_version: Api Version. Default value is "2024-11-01". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None: - api_version: str = kwargs.pop("api_version", "2023-07-01") + api_version: str = kwargs.pop("api_version", "2024-11-01") if credential is None: raise ValueError("Parameter 'credential' must not be None.") diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/_key_vault_management_client.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/_key_vault_management_client.py similarity index 85% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/_key_vault_management_client.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/_key_vault_management_client.py index 0f7ca3922ec9..8929bd549486 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/_key_vault_management_client.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/_key_vault_management_client.py @@ -33,41 +33,40 @@ ) if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials_async import AsyncTokenCredential -class KeyVaultManagementClient: # pylint: disable=client-accepts-api-version-keyword,too-many-instance-attributes +class KeyVaultManagementClient: # pylint: disable=too-many-instance-attributes """The Azure management API provides a RESTful set of web services that interact with Azure Key Vault. :ivar keys: KeysOperations operations - :vartype keys: azure.mgmt.keyvault.v2023_07_01.aio.operations.KeysOperations + :vartype keys: azure.mgmt.keyvault.v2024_11_01.aio.operations.KeysOperations :ivar managed_hsm_keys: ManagedHsmKeysOperations operations :vartype managed_hsm_keys: - azure.mgmt.keyvault.v2023_07_01.aio.operations.ManagedHsmKeysOperations + azure.mgmt.keyvault.v2024_11_01.aio.operations.ManagedHsmKeysOperations :ivar vaults: VaultsOperations operations - :vartype vaults: azure.mgmt.keyvault.v2023_07_01.aio.operations.VaultsOperations + :vartype vaults: azure.mgmt.keyvault.v2024_11_01.aio.operations.VaultsOperations :ivar private_endpoint_connections: PrivateEndpointConnectionsOperations operations :vartype private_endpoint_connections: - azure.mgmt.keyvault.v2023_07_01.aio.operations.PrivateEndpointConnectionsOperations + azure.mgmt.keyvault.v2024_11_01.aio.operations.PrivateEndpointConnectionsOperations :ivar private_link_resources: PrivateLinkResourcesOperations operations :vartype private_link_resources: - azure.mgmt.keyvault.v2023_07_01.aio.operations.PrivateLinkResourcesOperations + azure.mgmt.keyvault.v2024_11_01.aio.operations.PrivateLinkResourcesOperations :ivar managed_hsms: ManagedHsmsOperations operations - :vartype managed_hsms: azure.mgmt.keyvault.v2023_07_01.aio.operations.ManagedHsmsOperations + :vartype managed_hsms: azure.mgmt.keyvault.v2024_11_01.aio.operations.ManagedHsmsOperations :ivar mhsm_private_endpoint_connections: MHSMPrivateEndpointConnectionsOperations operations :vartype mhsm_private_endpoint_connections: - azure.mgmt.keyvault.v2023_07_01.aio.operations.MHSMPrivateEndpointConnectionsOperations + azure.mgmt.keyvault.v2024_11_01.aio.operations.MHSMPrivateEndpointConnectionsOperations :ivar mhsm_private_link_resources: MHSMPrivateLinkResourcesOperations operations :vartype mhsm_private_link_resources: - azure.mgmt.keyvault.v2023_07_01.aio.operations.MHSMPrivateLinkResourcesOperations + azure.mgmt.keyvault.v2024_11_01.aio.operations.MHSMPrivateLinkResourcesOperations :ivar mhsm_regions: MHSMRegionsOperations operations - :vartype mhsm_regions: azure.mgmt.keyvault.v2023_07_01.aio.operations.MHSMRegionsOperations + :vartype mhsm_regions: azure.mgmt.keyvault.v2024_11_01.aio.operations.MHSMRegionsOperations :ivar operations: Operations operations - :vartype operations: azure.mgmt.keyvault.v2023_07_01.aio.operations.Operations + :vartype operations: azure.mgmt.keyvault.v2024_11_01.aio.operations.Operations :ivar secrets: SecretsOperations operations - :vartype secrets: azure.mgmt.keyvault.v2023_07_01.aio.operations.SecretsOperations + :vartype secrets: azure.mgmt.keyvault.v2024_11_01.aio.operations.SecretsOperations :param credential: Credential needed for the client to connect to Azure. Required. :type credential: ~azure.core.credentials_async.AsyncTokenCredential :param subscription_id: Subscription credentials which uniquely identify Microsoft Azure @@ -75,7 +74,7 @@ class KeyVaultManagementClient: # pylint: disable=client-accepts-api-version-ke :type subscription_id: str :param base_url: Service URL. Default value is "https://management.azure.com". :type base_url: str - :keyword api_version: Api Version. Default value is "2023-07-01". Note that overriding this + :keyword api_version: Api Version. Default value is "2024-11-01". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str :keyword int polling_interval: Default waiting time between two polls for LRO operations if no @@ -116,31 +115,31 @@ def __init__( self._serialize = Serializer(client_models) self._deserialize = Deserializer(client_models) self._serialize.client_side_validation = False - self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize, "2023-07-01") + self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize, "2024-11-01") self.managed_hsm_keys = ManagedHsmKeysOperations( - self._client, self._config, self._serialize, self._deserialize, "2023-07-01" + self._client, self._config, self._serialize, self._deserialize, "2024-11-01" ) - self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize, "2023-07-01") + self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize, "2024-11-01") self.private_endpoint_connections = PrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2023-07-01" + self._client, self._config, self._serialize, self._deserialize, "2024-11-01" ) self.private_link_resources = PrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2023-07-01" + self._client, self._config, self._serialize, self._deserialize, "2024-11-01" ) self.managed_hsms = ManagedHsmsOperations( - self._client, self._config, self._serialize, self._deserialize, "2023-07-01" + self._client, self._config, self._serialize, self._deserialize, "2024-11-01" ) self.mhsm_private_endpoint_connections = MHSMPrivateEndpointConnectionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2023-07-01" + self._client, self._config, self._serialize, self._deserialize, "2024-11-01" ) self.mhsm_private_link_resources = MHSMPrivateLinkResourcesOperations( - self._client, self._config, self._serialize, self._deserialize, "2023-07-01" + self._client, self._config, self._serialize, self._deserialize, "2024-11-01" ) self.mhsm_regions = MHSMRegionsOperations( - self._client, self._config, self._serialize, self._deserialize, "2023-07-01" + self._client, self._config, self._serialize, self._deserialize, "2024-11-01" ) - self.operations = Operations(self._client, self._config, self._serialize, self._deserialize, "2023-07-01") - self.secrets = SecretsOperations(self._client, self._config, self._serialize, self._deserialize, "2023-07-01") + self.operations = Operations(self._client, self._config, self._serialize, self._deserialize, "2024-11-01") + self.secrets = SecretsOperations(self._client, self._config, self._serialize, self._deserialize, "2024-11-01") def _send_request( self, request: HttpRequest, *, stream: bool = False, **kwargs: Any diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/_patch.py similarity index 100% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/_patch.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/_patch.py diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/__init__.py similarity index 59% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/__init__.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/__init__.py index 5f02a0a74b92..2c20c64a2fa5 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/__init__.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/__init__.py @@ -5,21 +5,27 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +# pylint: disable=wrong-import-position -from ._keys_operations import KeysOperations -from ._managed_hsm_keys_operations import ManagedHsmKeysOperations -from ._vaults_operations import VaultsOperations -from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations -from ._private_link_resources_operations import PrivateLinkResourcesOperations -from ._managed_hsms_operations import ManagedHsmsOperations -from ._mhsm_private_endpoint_connections_operations import MHSMPrivateEndpointConnectionsOperations -from ._mhsm_private_link_resources_operations import MHSMPrivateLinkResourcesOperations -from ._mhsm_regions_operations import MHSMRegionsOperations -from ._operations import Operations -from ._secrets_operations import SecretsOperations +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._keys_operations import KeysOperations # type: ignore +from ._managed_hsm_keys_operations import ManagedHsmKeysOperations # type: ignore +from ._vaults_operations import VaultsOperations # type: ignore +from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations # type: ignore +from ._private_link_resources_operations import PrivateLinkResourcesOperations # type: ignore +from ._managed_hsms_operations import ManagedHsmsOperations # type: ignore +from ._mhsm_private_endpoint_connections_operations import MHSMPrivateEndpointConnectionsOperations # type: ignore +from ._mhsm_private_link_resources_operations import MHSMPrivateLinkResourcesOperations # type: ignore +from ._mhsm_regions_operations import MHSMRegionsOperations # type: ignore +from ._operations import Operations # type: ignore +from ._secrets_operations import SecretsOperations # type: ignore from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import +from ._patch import * from ._patch import patch_sdk as _patch_sdk __all__ = [ @@ -35,5 +41,5 @@ "Operations", "SecretsOperations", ] -__all__.extend([p for p in _patch_all if p not in __all__]) +__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_keys_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_keys_operations.py similarity index 94% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_keys_operations.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_keys_operations.py index 5e430b5afcc5..6ce0989a9a9b 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_keys_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_keys_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +7,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, Type, TypeVar, Union, overload +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList @@ -39,7 +38,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -50,7 +49,7 @@ class KeysOperations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2022_07_01.aio.KeyVaultManagementClient`'s + :class:`~azure.mgmt.keyvault.v2024_11_01.aio.KeyVaultManagementClient`'s :attr:`keys` attribute. """ @@ -89,12 +88,12 @@ async def create_if_not_exist( personally identifiable or sensitive information. Required. :type key_name: str :param parameters: The parameters used to create the specified key. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.KeyCreateParameters + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.KeyCreateParameters :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Key + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Key :raises ~azure.core.exceptions.HttpResponseError: """ @@ -128,7 +127,7 @@ async def create_if_not_exist( Default value is "application/json". :paramtype content_type: str :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Key + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Key :raises ~azure.core.exceptions.HttpResponseError: """ @@ -156,12 +155,12 @@ async def create_if_not_exist( :type key_name: str :param parameters: The parameters used to create the specified key. Is either a KeyCreateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.KeyCreateParameters or IO[bytes] + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.KeyCreateParameters or IO[bytes] :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Key + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Key :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -172,7 +171,7 @@ async def create_if_not_exist( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.Key] = kwargs.pop("cls", None) @@ -228,10 +227,10 @@ async def get(self, resource_group_name: str, vault_name: str, key_name: str, ** :param key_name: The name of the key to be retrieved. Required. :type key_name: str :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Key + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Key :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -242,7 +241,7 @@ async def get(self, resource_group_name: str, vault_name: str, key_name: str, ** _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.Key] = kwargs.pop("cls", None) _request = build_get_request( @@ -284,16 +283,16 @@ def list(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> Asyn :param vault_name: The name of the vault which contains the keys to be retrieved. Required. :type vault_name: str :return: An iterator like instance of either Key or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.Key] + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.Key] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -372,10 +371,10 @@ async def get_version( :param key_version: The version of the key to be retrieved. Required. :type key_version: str :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Key + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Key :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -386,7 +385,7 @@ async def get_version( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.Key] = kwargs.pop("cls", None) _request = build_get_version_request( @@ -434,16 +433,16 @@ def list_versions( :param key_name: The name of the key versions to be retrieved. Required. :type key_name: str :return: An iterator like instance of either Key or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.Key] + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.Key] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_managed_hsm_keys_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_managed_hsm_keys_operations.py similarity index 94% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_managed_hsm_keys_operations.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_managed_hsm_keys_operations.py index 61cce69b15d7..5c521a9c2de8 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_managed_hsm_keys_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_managed_hsm_keys_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +7,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, Type, TypeVar, Union, overload +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList @@ -39,7 +38,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -50,7 +49,7 @@ class ManagedHsmKeysOperations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2023_07_01.aio.KeyVaultManagementClient`'s + :class:`~azure.mgmt.keyvault.v2024_11_01.aio.KeyVaultManagementClient`'s :attr:`managed_hsm_keys` attribute. """ @@ -89,12 +88,12 @@ async def create_if_not_exist( personally identifiable or sensitive information. Required. :type key_name: str :param parameters: The parameters used to create the specified key. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKeyCreateParameters + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKeyCreateParameters :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: ManagedHsmKey or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKey + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKey :raises ~azure.core.exceptions.HttpResponseError: """ @@ -128,7 +127,7 @@ async def create_if_not_exist( Default value is "application/json". :paramtype content_type: str :return: ManagedHsmKey or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKey + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKey :raises ~azure.core.exceptions.HttpResponseError: """ @@ -156,13 +155,13 @@ async def create_if_not_exist( :type key_name: str :param parameters: The parameters used to create the specified key. Is either a ManagedHsmKeyCreateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKeyCreateParameters or + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKeyCreateParameters or IO[bytes] :return: ManagedHsmKey or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKey + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKey :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -173,7 +172,7 @@ async def create_if_not_exist( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.ManagedHsmKey] = kwargs.pop("cls", None) @@ -231,10 +230,10 @@ async def get(self, resource_group_name: str, name: str, key_name: str, **kwargs personally identifiable or sensitive information. Required. :type key_name: str :return: ManagedHsmKey or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKey + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKey :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -245,7 +244,7 @@ async def get(self, resource_group_name: str, name: str, key_name: str, **kwargs _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.ManagedHsmKey] = kwargs.pop("cls", None) _request = build_get_request( @@ -288,16 +287,16 @@ def list(self, resource_group_name: str, name: str, **kwargs: Any) -> AsyncItera :type name: str :return: An iterator like instance of either ManagedHsmKey or the result of cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKey] + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKey] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.ManagedHsmKeyListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -377,10 +376,10 @@ async def get_version( :param key_version: The version of the key to be retrieved. Required. :type key_version: str :return: ManagedHsmKey or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKey + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKey :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -391,7 +390,7 @@ async def get_version( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.ManagedHsmKey] = kwargs.pop("cls", None) _request = build_get_version_request( @@ -441,16 +440,16 @@ def list_versions( :type key_name: str :return: An iterator like instance of either ManagedHsmKey or the result of cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKey] + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKey] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.ManagedHsmKeyListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_managed_hsms_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_managed_hsms_operations.py similarity index 92% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_managed_hsms_operations.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_managed_hsms_operations.py index a23f5a087cf6..59665a1e9424 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/aio/operations/_managed_hsms_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_managed_hsms_operations.py @@ -1,4 +1,4 @@ -# pylint: disable=too-many-lines,too-many-statements +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +8,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, Type, TypeVar, Union, cast, overload +from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList @@ -18,6 +18,8 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.pipeline import PipelineResponse @@ -46,7 +48,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -57,7 +59,7 @@ class ManagedHsmsOperations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2022_07_01.aio.KeyVaultManagementClient`'s + :class:`~azure.mgmt.keyvault.v2024_11_01.aio.KeyVaultManagementClient`'s :attr:`managed_hsms` attribute. """ @@ -74,7 +76,7 @@ def __init__(self, *args, **kwargs) -> None: async def _create_or_update_initial( self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -85,7 +87,7 @@ async def _create_or_update_initial( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) @@ -110,6 +112,7 @@ async def _create_or_update_initial( ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -118,19 +121,19 @@ async def _create_or_update_initial( response = pipeline_response.http_response if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - if response.status_code == 202: response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -155,13 +158,13 @@ async def begin_create_or_update( :param name: Name of the managed HSM Pool. Required. :type name: str :param parameters: Parameters to create or update the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm] + :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm] :raises ~azure.core.exceptions.HttpResponseError: """ @@ -189,7 +192,7 @@ async def begin_create_or_update( :paramtype content_type: str :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm] + :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm] :raises ~azure.core.exceptions.HttpResponseError: """ @@ -206,16 +209,16 @@ async def begin_create_or_update( :type name: str :param parameters: Parameters to create or update the managed HSM Pool. Is either a ManagedHsm type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm or IO[bytes] + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm or IO[bytes] :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm] + :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) @@ -262,7 +265,7 @@ def get_long_running_output(pipeline_response): async def _update_initial( self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -273,7 +276,7 @@ async def _update_initial( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) @@ -298,6 +301,7 @@ async def _update_initial( ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -306,19 +310,19 @@ async def _update_initial( response = pipeline_response.http_response if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - if response.status_code == 202: response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -343,13 +347,13 @@ async def begin_update( :param name: Name of the managed HSM Pool. Required. :type name: str :param parameters: Parameters to patch the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm] + :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm] :raises ~azure.core.exceptions.HttpResponseError: """ @@ -377,7 +381,7 @@ async def begin_update( :paramtype content_type: str :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm] + :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm] :raises ~azure.core.exceptions.HttpResponseError: """ @@ -394,16 +398,16 @@ async def begin_update( :type name: str :param parameters: Parameters to patch the managed HSM Pool. Is either a ManagedHsm type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm or IO[bytes] + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm or IO[bytes] :return: An instance of AsyncLROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm] + :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) @@ -448,7 +452,7 @@ def get_long_running_output(pipeline_response): ) async def _delete_initial(self, resource_group_name: str, name: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -459,7 +463,7 @@ async def _delete_initial(self, resource_group_name: str, name: str, **kwargs: A _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) _request = build_delete_request( @@ -472,6 +476,7 @@ async def _delete_initial(self, resource_group_name: str, name: str, **kwargs: A ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -480,22 +485,19 @@ async def _delete_initial(self, resource_group_name: str, name: str, **kwargs: A response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: - await response.read() # Load the body in memory and close the socket + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - if response.status_code == 202: response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -518,7 +520,7 @@ async def begin_delete(self, resource_group_name: str, name: str, **kwargs: Any) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[None] = kwargs.pop("cls", None) polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) @@ -565,10 +567,10 @@ async def get(self, resource_group_name: str, name: str, **kwargs: Any) -> Optio :param name: The name of the managed HSM Pool. Required. :type name: str :return: ManagedHsm or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm or None + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm or None :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -579,7 +581,7 @@ async def get(self, resource_group_name: str, name: str, **kwargs: Any) -> Optio _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[Optional[_models.ManagedHsm]] = kwargs.pop("cls", None) _request = build_get_request( @@ -627,16 +629,16 @@ def list_by_resource_group( :type top: int :return: An iterator like instance of either ManagedHsm or the result of cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm] + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -708,16 +710,16 @@ def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> Asyn :type top: int :return: An iterator like instance of either ManagedHsm or the result of cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm] + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -786,16 +788,16 @@ def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedManagedHs :return: An iterator like instance of either DeletedManagedHsm or the result of cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.DeletedManagedHsm] + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.DeletedManagedHsm] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.DeletedManagedHsmListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -865,10 +867,10 @@ async def get_deleted(self, name: str, location: str, **kwargs: Any) -> _models. :param location: The location of the deleted managed HSM. Required. :type location: str :return: DeletedManagedHsm or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.DeletedManagedHsm + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.DeletedManagedHsm :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -879,7 +881,7 @@ async def get_deleted(self, name: str, location: str, **kwargs: Any) -> _models. _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.DeletedManagedHsm] = kwargs.pop("cls", None) _request = build_get_deleted_request( @@ -912,7 +914,7 @@ async def get_deleted(self, name: str, location: str, **kwargs: Any) -> _models. return deserialized # type: ignore async def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -923,7 +925,7 @@ async def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) _request = build_purge_deleted_request( @@ -936,6 +938,7 @@ async def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -944,7 +947,10 @@ async def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) response = pipeline_response.http_response if response.status_code not in [202]: - await response.read() # Load the body in memory and close the socket + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) @@ -952,7 +958,7 @@ async def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) response_headers = {} response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -974,7 +980,7 @@ async def begin_purge_deleted(self, name: str, location: str, **kwargs: Any) -> _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[None] = kwargs.pop("cls", None) polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) @@ -1022,12 +1028,12 @@ async def check_mhsm_name_availability( """Checks that the managed hsm name is valid and is not already in use. :param mhsm_name: The name of the managed hsm. Required. - :type mhsm_name: ~azure.mgmt.keyvault.v2022_07_01.models.CheckMhsmNameAvailabilityParameters + :type mhsm_name: ~azure.mgmt.keyvault.v2024_11_01.models.CheckMhsmNameAvailabilityParameters :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: CheckMhsmNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.CheckMhsmNameAvailabilityResult + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.CheckMhsmNameAvailabilityResult :raises ~azure.core.exceptions.HttpResponseError: """ @@ -1043,7 +1049,7 @@ async def check_mhsm_name_availability( Default value is "application/json". :paramtype content_type: str :return: CheckMhsmNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.CheckMhsmNameAvailabilityResult + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.CheckMhsmNameAvailabilityResult :raises ~azure.core.exceptions.HttpResponseError: """ @@ -1055,13 +1061,13 @@ async def check_mhsm_name_availability( :param mhsm_name: The name of the managed hsm. Is either a CheckMhsmNameAvailabilityParameters type or a IO[bytes] type. Required. - :type mhsm_name: ~azure.mgmt.keyvault.v2022_07_01.models.CheckMhsmNameAvailabilityParameters or + :type mhsm_name: ~azure.mgmt.keyvault.v2024_11_01.models.CheckMhsmNameAvailabilityParameters or IO[bytes] :return: CheckMhsmNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.CheckMhsmNameAvailabilityResult + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.CheckMhsmNameAvailabilityResult :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1072,7 +1078,7 @@ async def check_mhsm_name_availability( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.CheckMhsmNameAvailabilityResult] = kwargs.pop("cls", None) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_mhsm_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_mhsm_private_endpoint_connections_operations.py similarity index 92% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_mhsm_private_endpoint_connections_operations.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_mhsm_private_endpoint_connections_operations.py index 16c169a8eaa0..9a68d1dd5469 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_mhsm_private_endpoint_connections_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_mhsm_private_endpoint_connections_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +7,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, Type, TypeVar, Union, cast, overload +from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList @@ -18,6 +17,8 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.pipeline import PipelineResponse @@ -40,7 +41,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -51,7 +52,7 @@ class MHSMPrivateEndpointConnectionsOperations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2023_07_01.aio.KeyVaultManagementClient`'s + :class:`~azure.mgmt.keyvault.v2024_11_01.aio.KeyVaultManagementClient`'s :attr:`mhsm_private_endpoint_connections` attribute. """ @@ -80,16 +81,16 @@ def list_by_resource( :return: An iterator like instance of either MHSMPrivateEndpointConnection or the result of cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpointConnection] + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpointConnection] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -167,10 +168,10 @@ async def get( with the managed hsm pool. Required. :type private_endpoint_connection_name: str :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpointConnection + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpointConnection :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -181,7 +182,7 @@ async def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) _request = build_get_request( @@ -236,12 +237,12 @@ async def put( with the managed hsm pool. Required. :type private_endpoint_connection_name: str :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpointConnection + :type properties: ~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpointConnection :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpointConnection + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpointConnection :raises ~azure.core.exceptions.HttpResponseError: """ @@ -272,7 +273,7 @@ async def put( Default value is "application/json". :paramtype content_type: str :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpointConnection + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpointConnection :raises ~azure.core.exceptions.HttpResponseError: """ @@ -297,13 +298,13 @@ async def put( :type private_endpoint_connection_name: str :param properties: The intended state of private endpoint connection. Is either a MHSMPrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpointConnection or + :type properties: ~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpointConnection or IO[bytes] :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpointConnection + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpointConnection :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -314,7 +315,7 @@ async def put( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) @@ -367,7 +368,7 @@ async def put( async def _delete_initial( self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -378,7 +379,7 @@ async def _delete_initial( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) _request = build_delete_request( @@ -392,6 +393,7 @@ async def _delete_initial( ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -400,21 +402,18 @@ async def _delete_initial( response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: - await response.read() # Load the body in memory and close the socket + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - if response.status_code == 202: response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -438,13 +437,13 @@ async def begin_delete( :return: An instance of AsyncLROPoller that returns either MHSMPrivateEndpointConnection or the result of cls(response) :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpointConnection] + ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpointConnection] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_mhsm_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_mhsm_private_link_resources_operations.py similarity index 90% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_mhsm_private_link_resources_operations.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_mhsm_private_link_resources_operations.py index c3df2ee1e4b3..8e4a2c7c1404 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/aio/operations/_mhsm_private_link_resources_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_mhsm_private_link_resources_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,7 +6,7 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar +from typing import Any, Callable, Dict, Optional, TypeVar from azure.core.exceptions import ( ClientAuthenticationError, @@ -29,7 +28,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -40,7 +39,7 @@ class MHSMPrivateLinkResourcesOperations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_10_01.aio.KeyVaultManagementClient`'s + :class:`~azure.mgmt.keyvault.v2024_11_01.aio.KeyVaultManagementClient`'s :attr:`mhsm_private_link_resources` attribute. """ @@ -66,10 +65,10 @@ async def list_by_mhsm_resource( :param name: Name of the managed HSM Pool. Required. :type name: str :return: MHSMPrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateLinkResourceListResult + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateLinkResourceListResult :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -80,7 +79,7 @@ async def list_by_mhsm_resource( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.MHSMPrivateLinkResourceListResult] = kwargs.pop("cls", None) _request = build_list_by_mhsm_resource_request( diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_mhsm_regions_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_mhsm_regions_operations.py similarity index 93% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_mhsm_regions_operations.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_mhsm_regions_operations.py index e165553dbdd1..b87b2a1ce9db 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_mhsm_regions_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_mhsm_regions_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,7 +6,7 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import sys -from typing import Any, AsyncIterable, Callable, Dict, Optional, Type, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList @@ -31,7 +30,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -42,7 +41,7 @@ class MHSMRegionsOperations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2023_07_01.aio.KeyVaultManagementClient`'s + :class:`~azure.mgmt.keyvault.v2024_11_01.aio.KeyVaultManagementClient`'s :attr:`mhsm_regions` attribute. """ @@ -70,16 +69,16 @@ def list_by_resource( :return: An iterator like instance of either MHSMGeoReplicatedRegion or the result of cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.MHSMGeoReplicatedRegion] + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.MHSMGeoReplicatedRegion] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.MHSMRegionsListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/operations/_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_operations.py similarity index 93% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/operations/_operations.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_operations.py index fbf2685f8ee3..ca2afba862bc 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/operations/_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,7 +6,7 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import sys -from typing import Any, AsyncIterable, Callable, Dict, Optional, Type, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList @@ -31,7 +30,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -42,7 +41,7 @@ class Operations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2019_09_01.aio.KeyVaultManagementClient`'s + :class:`~azure.mgmt.keyvault.v2024_11_01.aio.KeyVaultManagementClient`'s :attr:`operations` attribute. """ @@ -62,16 +61,16 @@ def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: :return: An iterator like instance of either Operation or the result of cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.Operation] + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.Operation] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2019-09-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/models/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_patch.py similarity index 100% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/models/_patch.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_patch.py diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_private_endpoint_connections_operations.py similarity index 92% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_private_endpoint_connections_operations.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_private_endpoint_connections_operations.py index 1f1a9bb4d5cb..eaa9f5e87e75 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_private_endpoint_connections_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_private_endpoint_connections_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +7,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, Type, TypeVar, Union, cast, overload +from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList @@ -18,6 +17,8 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.pipeline import PipelineResponse @@ -40,7 +41,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -51,7 +52,7 @@ class PrivateEndpointConnectionsOperations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2023_07_01.aio.KeyVaultManagementClient`'s + :class:`~azure.mgmt.keyvault.v2024_11_01.aio.KeyVaultManagementClient`'s :attr:`private_endpoint_connections` attribute. """ @@ -79,10 +80,10 @@ async def get( with the key vault. Required. :type private_endpoint_connection_name: str :return: PrivateEndpointConnection or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnection or None + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnection or None :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -93,7 +94,7 @@ async def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[Optional[_models.PrivateEndpointConnection]] = kwargs.pop("cls", None) _request = build_get_request( @@ -148,12 +149,12 @@ async def put( with the key vault. Required. :type private_endpoint_connection_name: str :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnection + :type properties: ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnection :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnection + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnection :raises ~azure.core.exceptions.HttpResponseError: """ @@ -183,7 +184,7 @@ async def put( Default value is "application/json". :paramtype content_type: str :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnection + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnection :raises ~azure.core.exceptions.HttpResponseError: """ @@ -207,13 +208,13 @@ async def put( :type private_endpoint_connection_name: str :param properties: The intended state of private endpoint connection. Is either a PrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnection or + :type properties: ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnection or IO[bytes] :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnection + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnection :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -224,7 +225,7 @@ async def put( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) @@ -277,7 +278,7 @@ async def put( async def _delete_initial( self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -288,7 +289,7 @@ async def _delete_initial( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) _request = build_delete_request( @@ -302,6 +303,7 @@ async def _delete_initial( ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -310,22 +312,19 @@ async def _delete_initial( response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: - await response.read() # Load the body in memory and close the socket + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - if response.status_code == 202: response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -348,13 +347,13 @@ async def begin_delete( :return: An instance of AsyncLROPoller that returns either PrivateEndpointConnection or the result of cls(response) :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnection] + ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnection] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) @@ -410,16 +409,16 @@ def list_by_resource( :return: An iterator like instance of either PrivateEndpointConnection or the result of cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnection] + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnection] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.PrivateEndpointConnectionListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/operations/_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_private_link_resources_operations.py similarity index 90% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/operations/_private_link_resources_operations.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_private_link_resources_operations.py index a8f0271562ad..5753dc5061b3 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/operations/_private_link_resources_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_private_link_resources_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,7 +6,7 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar +from typing import Any, Callable, Dict, Optional, TypeVar from azure.core.exceptions import ( ClientAuthenticationError, @@ -29,7 +28,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -40,7 +39,7 @@ class PrivateLinkResourcesOperations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2018_02_14.aio.KeyVaultManagementClient`'s + :class:`~azure.mgmt.keyvault.v2024_11_01.aio.KeyVaultManagementClient`'s :attr:`private_link_resources` attribute. """ @@ -65,10 +64,10 @@ async def list_by_vault( :param vault_name: The name of the key vault. Required. :type vault_name: str :return: PrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateLinkResourceListResult + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.PrivateLinkResourceListResult :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -79,7 +78,7 @@ async def list_by_vault( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.PrivateLinkResourceListResult] = kwargs.pop("cls", None) _request = build_list_by_vault_request( diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_secrets_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_secrets_operations.py similarity index 91% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_secrets_operations.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_secrets_operations.py index f9e5860b05d5..229264b84afb 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/aio/operations/_secrets_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_secrets_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +7,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, Type, TypeVar, Union, overload +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList @@ -38,7 +37,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -49,7 +48,7 @@ class SecretsOperations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2023_07_01.aio.KeyVaultManagementClient`'s + :class:`~azure.mgmt.keyvault.v2024_11_01.aio.KeyVaultManagementClient`'s :attr:`secrets` attribute. """ @@ -88,12 +87,12 @@ async def create_or_update( or sensitive information. Required. :type secret_name: str :param parameters: Parameters to create or update the secret. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.SecretCreateOrUpdateParameters + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.SecretCreateOrUpdateParameters :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Secret + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Secret :raises ~azure.core.exceptions.HttpResponseError: """ @@ -127,7 +126,7 @@ async def create_or_update( Default value is "application/json". :paramtype content_type: str :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Secret + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Secret :raises ~azure.core.exceptions.HttpResponseError: """ @@ -155,13 +154,13 @@ async def create_or_update( :type secret_name: str :param parameters: Parameters to create or update the secret. Is either a SecretCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.SecretCreateOrUpdateParameters or + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.SecretCreateOrUpdateParameters or IO[bytes] :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Secret + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Secret :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -172,7 +171,7 @@ async def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.Secret] = kwargs.pop("cls", None) @@ -209,11 +208,7 @@ async def create_or_update( map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) + deserialized = self._deserialize("Secret", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -243,12 +238,12 @@ async def update( :param secret_name: Name of the secret. Required. :type secret_name: str :param parameters: Parameters to patch the secret. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.SecretPatchParameters + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.SecretPatchParameters :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Secret + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Secret :raises ~azure.core.exceptions.HttpResponseError: """ @@ -280,7 +275,7 @@ async def update( Default value is "application/json". :paramtype content_type: str :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Secret + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Secret :raises ~azure.core.exceptions.HttpResponseError: """ @@ -306,12 +301,12 @@ async def update( :type secret_name: str :param parameters: Parameters to patch the secret. Is either a SecretPatchParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.SecretPatchParameters or IO[bytes] + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.SecretPatchParameters or IO[bytes] :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Secret + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Secret :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -322,7 +317,7 @@ async def update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.Secret] = kwargs.pop("cls", None) @@ -359,11 +354,7 @@ async def update( map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) + deserialized = self._deserialize("Secret", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -383,10 +374,10 @@ async def get(self, resource_group_name: str, vault_name: str, secret_name: str, :param secret_name: The name of the secret. Required. :type secret_name: str :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Secret + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Secret :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -397,7 +388,7 @@ async def get(self, resource_group_name: str, vault_name: str, secret_name: str, _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.Secret] = kwargs.pop("cls", None) _request = build_get_request( @@ -445,16 +436,16 @@ def list( :param top: Maximum number of results to return. Default value is None. :type top: int :return: An iterator like instance of either Secret or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.Secret] + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.Secret] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.SecretListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/operations/_vaults_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_vaults_operations.py similarity index 91% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/operations/_vaults_operations.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_vaults_operations.py index 7af173be952b..1de42133ac25 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/operations/_vaults_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/aio/operations/_vaults_operations.py @@ -1,4 +1,4 @@ -# pylint: disable=too-many-lines,too-many-statements +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -17,7 +17,6 @@ IO, Literal, Optional, - Type, TypeVar, Union, cast, @@ -32,6 +31,8 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.pipeline import PipelineResponse @@ -62,7 +63,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -73,7 +74,7 @@ class VaultsOperations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2018_02_14.aio.KeyVaultManagementClient`'s + :class:`~azure.mgmt.keyvault.v2024_11_01.aio.KeyVaultManagementClient`'s :attr:`vaults` attribute. """ @@ -94,7 +95,7 @@ async def _create_or_update_initial( parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], **kwargs: Any ) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -105,7 +106,7 @@ async def _create_or_update_initial( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) @@ -130,6 +131,7 @@ async def _create_or_update_initial( ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -138,15 +140,14 @@ async def _create_or_update_initial( response = pipeline_response.http_response if response.status_code not in [200, 201]: - await response.read() # Load the body in memory and close the socket + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 201: - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -171,12 +172,12 @@ async def begin_create_or_update( :param vault_name: Name of the vault. Required. :type vault_name: str :param parameters: Parameters to create or update the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2018_02_14.models.VaultCreateOrUpdateParameters + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.VaultCreateOrUpdateParameters :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2018_02_14.models.Vault] + :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2024_11_01.models.Vault] :raises ~azure.core.exceptions.HttpResponseError: """ @@ -203,7 +204,7 @@ async def begin_create_or_update( Default value is "application/json". :paramtype content_type: str :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2018_02_14.models.Vault] + :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2024_11_01.models.Vault] :raises ~azure.core.exceptions.HttpResponseError: """ @@ -224,16 +225,16 @@ async def begin_create_or_update( :type vault_name: str :param parameters: Parameters to create or update the vault. Is either a VaultCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2018_02_14.models.VaultCreateOrUpdateParameters or + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.VaultCreateOrUpdateParameters or IO[bytes] :return: An instance of AsyncLROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2018_02_14.models.Vault] + :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2024_11_01.models.Vault] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.Vault] = kwargs.pop("cls", None) polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) @@ -295,12 +296,12 @@ async def update( :param vault_name: Name of the vault. Required. :type vault_name: str :param parameters: Parameters to patch the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2018_02_14.models.VaultPatchParameters + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.VaultPatchParameters :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.Vault + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Vault :raises ~azure.core.exceptions.HttpResponseError: """ @@ -327,7 +328,7 @@ async def update( Default value is "application/json". :paramtype content_type: str :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.Vault + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Vault :raises ~azure.core.exceptions.HttpResponseError: """ @@ -348,12 +349,12 @@ async def update( :type vault_name: str :param parameters: Parameters to patch the vault. Is either a VaultPatchParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2018_02_14.models.VaultPatchParameters or IO[bytes] + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.VaultPatchParameters or IO[bytes] :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.Vault + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Vault :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -364,7 +365,7 @@ async def update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.Vault] = kwargs.pop("cls", None) @@ -400,11 +401,7 @@ async def update( map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Vault", pipeline_response.http_response) + deserialized = self._deserialize("Vault", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -412,9 +409,7 @@ async def update( return deserialized # type: ignore @distributed_trace_async - async def delete( # pylint: disable=inconsistent-return-statements - self, resource_group_name: str, vault_name: str, **kwargs: Any - ) -> None: + async def delete(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> None: """Deletes the specified Azure key vault. :param resource_group_name: The name of the Resource Group to which the vault belongs. @@ -426,7 +421,7 @@ async def delete( # pylint: disable=inconsistent-return-statements :rtype: None :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -437,7 +432,7 @@ async def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[None] = kwargs.pop("cls", None) _request = build_delete_request( @@ -474,10 +469,10 @@ async def get(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> :param vault_name: The name of the vault. Required. :type vault_name: str :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.Vault + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Vault :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -488,7 +483,7 @@ async def get(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.Vault] = kwargs.pop("cls", None) _request = build_get_request( @@ -539,14 +534,14 @@ async def update_access_policy( :type vault_name: str :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2018_02_14.models.AccessPolicyUpdateKind + :type operation_kind: str or ~azure.mgmt.keyvault.v2024_11_01.models.AccessPolicyUpdateKind :param parameters: Access policy to merge into the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2018_02_14.models.VaultAccessPolicyParameters + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.VaultAccessPolicyParameters :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.VaultAccessPolicyParameters + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.VaultAccessPolicyParameters :raises ~azure.core.exceptions.HttpResponseError: """ @@ -570,14 +565,14 @@ async def update_access_policy( :type vault_name: str :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2018_02_14.models.AccessPolicyUpdateKind + :type operation_kind: str or ~azure.mgmt.keyvault.v2024_11_01.models.AccessPolicyUpdateKind :param parameters: Access policy to merge into the vault. Required. :type parameters: IO[bytes] :keyword content_type: Body Parameter content-type. Content type parameter for binary body. Default value is "application/json". :paramtype content_type: str :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.VaultAccessPolicyParameters + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.VaultAccessPolicyParameters :raises ~azure.core.exceptions.HttpResponseError: """ @@ -599,16 +594,16 @@ async def update_access_policy( :type vault_name: str :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2018_02_14.models.AccessPolicyUpdateKind + :type operation_kind: str or ~azure.mgmt.keyvault.v2024_11_01.models.AccessPolicyUpdateKind :param parameters: Access policy to merge into the vault. Is either a VaultAccessPolicyParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2018_02_14.models.VaultAccessPolicyParameters or + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.VaultAccessPolicyParameters or IO[bytes] :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.VaultAccessPolicyParameters + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.VaultAccessPolicyParameters :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -619,7 +614,7 @@ async def update_access_policy( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.VaultAccessPolicyParameters] = kwargs.pop("cls", None) @@ -656,11 +651,7 @@ async def update_access_policy( map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -680,16 +671,16 @@ def list_by_resource_group( :param top: Maximum number of results to return. Default value is None. :type top: int :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2018_02_14.models.Vault] + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.Vault] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -758,16 +749,16 @@ def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> Asyn :param top: Maximum number of results to return. Default value is None. :type top: int :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2018_02_14.models.Vault] + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.Vault] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -834,16 +825,16 @@ def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedVault"]: :return: An iterator like instance of either DeletedVault or the result of cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2018_02_14.models.DeletedVault] + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.DeletedVault] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.DeletedVaultListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -912,10 +903,10 @@ async def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _m :param location: The location of the deleted vault. Required. :type location: str :return: DeletedVault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.DeletedVault + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.DeletedVault :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -926,7 +917,7 @@ async def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _m _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.DeletedVault] = kwargs.pop("cls", None) _request = build_get_deleted_request( @@ -958,7 +949,7 @@ async def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _m return deserialized # type: ignore async def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -969,7 +960,7 @@ async def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) _request = build_purge_deleted_request( @@ -982,6 +973,7 @@ async def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -990,15 +982,14 @@ async def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: response = pipeline_response.http_response if response.status_code not in [200, 202]: - await response.read() # Load the body in memory and close the socket + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -1020,7 +1011,7 @@ async def begin_purge_deleted(self, vault_name: str, location: str, **kwargs: An _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[None] = kwargs.pop("cls", None) polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) @@ -1065,7 +1056,7 @@ def list(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_mode :type top: int :return: An iterator like instance of either Resource or the result of cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2018_02_14.models.Resource] + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.Resource] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} @@ -1079,7 +1070,7 @@ def list(self, top: Optional[int] = None, **kwargs: Any) -> AsyncIterable["_mode ) cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1152,12 +1143,12 @@ async def check_name_availability( """Checks that the vault name is valid and is not already in use. :param vault_name: The name of the vault. Required. - :type vault_name: ~azure.mgmt.keyvault.v2018_02_14.models.VaultCheckNameAvailabilityParameters + :type vault_name: ~azure.mgmt.keyvault.v2024_11_01.models.VaultCheckNameAvailabilityParameters :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.CheckNameAvailabilityResult + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.CheckNameAvailabilityResult :raises ~azure.core.exceptions.HttpResponseError: """ @@ -1173,7 +1164,7 @@ async def check_name_availability( Default value is "application/json". :paramtype content_type: str :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.CheckNameAvailabilityResult + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.CheckNameAvailabilityResult :raises ~azure.core.exceptions.HttpResponseError: """ @@ -1185,13 +1176,13 @@ async def check_name_availability( :param vault_name: The name of the vault. Is either a VaultCheckNameAvailabilityParameters type or a IO[bytes] type. Required. - :type vault_name: ~azure.mgmt.keyvault.v2018_02_14.models.VaultCheckNameAvailabilityParameters + :type vault_name: ~azure.mgmt.keyvault.v2024_11_01.models.VaultCheckNameAvailabilityParameters or IO[bytes] :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.CheckNameAvailabilityResult + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.CheckNameAvailabilityResult :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1202,7 +1193,7 @@ async def check_name_availability( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2018-02-14")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.CheckNameAvailabilityResult] = kwargs.pop("cls", None) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/models/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/models/__init__.py new file mode 100644 index 000000000000..6ce51a3e2eec --- /dev/null +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/models/__init__.py @@ -0,0 +1,274 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +# pylint: disable=wrong-import-position + +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + + +from ._models_py3 import ( # type: ignore + AccessPolicyEntry, + Action, + Attributes, + CheckMhsmNameAvailabilityParameters, + CheckMhsmNameAvailabilityResult, + CheckNameAvailabilityResult, + CloudErrorBody, + DeletedManagedHsm, + DeletedManagedHsmListResult, + DeletedManagedHsmProperties, + DeletedVault, + DeletedVaultListResult, + DeletedVaultProperties, + DimensionProperties, + Error, + IPRule, + Key, + KeyAttributes, + KeyCreateParameters, + KeyListResult, + KeyProperties, + KeyReleasePolicy, + KeyRotationPolicyAttributes, + LifetimeAction, + LogSpecification, + MHSMGeoReplicatedRegion, + MHSMIPRule, + MHSMNetworkRuleSet, + MHSMPrivateEndpoint, + MHSMPrivateEndpointConnection, + MHSMPrivateEndpointConnectionItem, + MHSMPrivateEndpointConnectionsListResult, + MHSMPrivateLinkResource, + MHSMPrivateLinkResourceListResult, + MHSMPrivateLinkServiceConnectionState, + MHSMRegionsListResult, + MHSMVirtualNetworkRule, + ManagedHSMSecurityDomainProperties, + ManagedHsm, + ManagedHsmAction, + ManagedHsmError, + ManagedHsmKey, + ManagedHsmKeyAttributes, + ManagedHsmKeyCreateParameters, + ManagedHsmKeyListResult, + ManagedHsmKeyProperties, + ManagedHsmKeyReleasePolicy, + ManagedHsmKeyRotationPolicyAttributes, + ManagedHsmLifetimeAction, + ManagedHsmListResult, + ManagedHsmProperties, + ManagedHsmResource, + ManagedHsmRotationPolicy, + ManagedHsmSku, + ManagedHsmTrigger, + ManagedServiceIdentity, + MetricSpecification, + NetworkRuleSet, + Operation, + OperationDisplay, + OperationListResult, + Permissions, + PrivateEndpoint, + PrivateEndpointConnection, + PrivateEndpointConnectionItem, + PrivateEndpointConnectionListResult, + PrivateLinkResource, + PrivateLinkResourceListResult, + PrivateLinkServiceConnectionState, + ProxyResourceWithoutSystemData, + Resource, + ResourceListResult, + RotationPolicy, + Secret, + SecretAttributes, + SecretCreateOrUpdateParameters, + SecretListResult, + SecretPatchParameters, + SecretPatchProperties, + SecretProperties, + ServiceSpecification, + Sku, + SystemData, + Trigger, + UserAssignedIdentity, + Vault, + VaultAccessPolicyParameters, + VaultAccessPolicyProperties, + VaultCheckNameAvailabilityParameters, + VaultCreateOrUpdateParameters, + VaultListResult, + VaultPatchParameters, + VaultPatchProperties, + VaultProperties, + VirtualNetworkRule, +) + +from ._key_vault_management_client_enums import ( # type: ignore + AccessPolicyUpdateKind, + ActionsRequired, + ActivationStatus, + CertificatePermissions, + CreateMode, + DeletionRecoveryLevel, + GeoReplicationRegionProvisioningState, + IdentityType, + JsonWebKeyCurveName, + JsonWebKeyOperation, + JsonWebKeyType, + KeyPermissions, + KeyRotationPolicyActionType, + ManagedHsmSkuFamily, + ManagedHsmSkuName, + ManagedServiceIdentityType, + NetworkRuleAction, + NetworkRuleBypassOptions, + PrivateEndpointConnectionProvisioningState, + PrivateEndpointServiceConnectionStatus, + ProvisioningState, + PublicNetworkAccess, + Reason, + SecretPermissions, + SkuFamily, + SkuName, + StoragePermissions, + VaultProvisioningState, +) +from ._patch import __all__ as _patch_all +from ._patch import * +from ._patch import patch_sdk as _patch_sdk + +__all__ = [ + "AccessPolicyEntry", + "Action", + "Attributes", + "CheckMhsmNameAvailabilityParameters", + "CheckMhsmNameAvailabilityResult", + "CheckNameAvailabilityResult", + "CloudErrorBody", + "DeletedManagedHsm", + "DeletedManagedHsmListResult", + "DeletedManagedHsmProperties", + "DeletedVault", + "DeletedVaultListResult", + "DeletedVaultProperties", + "DimensionProperties", + "Error", + "IPRule", + "Key", + "KeyAttributes", + "KeyCreateParameters", + "KeyListResult", + "KeyProperties", + "KeyReleasePolicy", + "KeyRotationPolicyAttributes", + "LifetimeAction", + "LogSpecification", + "MHSMGeoReplicatedRegion", + "MHSMIPRule", + "MHSMNetworkRuleSet", + "MHSMPrivateEndpoint", + "MHSMPrivateEndpointConnection", + "MHSMPrivateEndpointConnectionItem", + "MHSMPrivateEndpointConnectionsListResult", + "MHSMPrivateLinkResource", + "MHSMPrivateLinkResourceListResult", + "MHSMPrivateLinkServiceConnectionState", + "MHSMRegionsListResult", + "MHSMVirtualNetworkRule", + "ManagedHSMSecurityDomainProperties", + "ManagedHsm", + "ManagedHsmAction", + "ManagedHsmError", + "ManagedHsmKey", + "ManagedHsmKeyAttributes", + "ManagedHsmKeyCreateParameters", + "ManagedHsmKeyListResult", + "ManagedHsmKeyProperties", + "ManagedHsmKeyReleasePolicy", + "ManagedHsmKeyRotationPolicyAttributes", + "ManagedHsmLifetimeAction", + "ManagedHsmListResult", + "ManagedHsmProperties", + "ManagedHsmResource", + "ManagedHsmRotationPolicy", + "ManagedHsmSku", + "ManagedHsmTrigger", + "ManagedServiceIdentity", + "MetricSpecification", + "NetworkRuleSet", + "Operation", + "OperationDisplay", + "OperationListResult", + "Permissions", + "PrivateEndpoint", + "PrivateEndpointConnection", + "PrivateEndpointConnectionItem", + "PrivateEndpointConnectionListResult", + "PrivateLinkResource", + "PrivateLinkResourceListResult", + "PrivateLinkServiceConnectionState", + "ProxyResourceWithoutSystemData", + "Resource", + "ResourceListResult", + "RotationPolicy", + "Secret", + "SecretAttributes", + "SecretCreateOrUpdateParameters", + "SecretListResult", + "SecretPatchParameters", + "SecretPatchProperties", + "SecretProperties", + "ServiceSpecification", + "Sku", + "SystemData", + "Trigger", + "UserAssignedIdentity", + "Vault", + "VaultAccessPolicyParameters", + "VaultAccessPolicyProperties", + "VaultCheckNameAvailabilityParameters", + "VaultCreateOrUpdateParameters", + "VaultListResult", + "VaultPatchParameters", + "VaultPatchProperties", + "VaultProperties", + "VirtualNetworkRule", + "AccessPolicyUpdateKind", + "ActionsRequired", + "ActivationStatus", + "CertificatePermissions", + "CreateMode", + "DeletionRecoveryLevel", + "GeoReplicationRegionProvisioningState", + "IdentityType", + "JsonWebKeyCurveName", + "JsonWebKeyOperation", + "JsonWebKeyType", + "KeyPermissions", + "KeyRotationPolicyActionType", + "ManagedHsmSkuFamily", + "ManagedHsmSkuName", + "ManagedServiceIdentityType", + "NetworkRuleAction", + "NetworkRuleBypassOptions", + "PrivateEndpointConnectionProvisioningState", + "PrivateEndpointServiceConnectionStatus", + "ProvisioningState", + "PublicNetworkAccess", + "Reason", + "SecretPermissions", + "SkuFamily", + "SkuName", + "StoragePermissions", + "VaultProvisioningState", +] +__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore +_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/models/_key_vault_management_client_enums.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/models/_key_vault_management_client_enums.py similarity index 98% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/models/_key_vault_management_client_enums.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/models/_key_vault_management_client_enums.py index 845f0c46e95f..37c7908f43d1 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/models/_key_vault_management_client_enums.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/models/_key_vault_management_client_enums.py @@ -100,7 +100,9 @@ class IdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta): class JsonWebKeyCurveName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The elliptic curve name. For valid values, see JsonWebKeyCurveName.""" + """The elliptic curve name. For valid values, see JsonWebKeyCurveName. Default for EC and EC-HSM + keys is P-256. + """ P256 = "P-256" P384 = "P-384" @@ -171,6 +173,7 @@ class ManagedHsmSkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): """SKU Family of the managed HSM Pool.""" B = "B" + C = "C" class ManagedHsmSkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta): @@ -179,6 +182,8 @@ class ManagedHsmSkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta): STANDARD_B1 = "Standard_B1" CUSTOM_B32 = "Custom_B32" CUSTOM_B6 = "Custom_B6" + CUSTOM_C42 = "Custom_C42" + CUSTOM_C10 = "Custom_C10" class ManagedServiceIdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta): diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/models/_models_py3.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/models/_models_py3.py similarity index 89% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/models/_models_py3.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/models/_models_py3.py index faea8e40fdc7..50beeee5e7f8 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/models/_models_py3.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/models/_models_py3.py @@ -1,5 +1,5 @@ -# coding=utf-8 # pylint: disable=too-many-lines +# coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. @@ -13,7 +13,6 @@ from ... import _serialization if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from .. import models as _models @@ -33,7 +32,7 @@ class AccessPolicyEntry(_serialization.Model): :ivar application_id: Application ID of the client making request on behalf of a principal. :vartype application_id: str :ivar permissions: Permissions the identity has for keys, secrets and certificates. Required. - :vartype permissions: ~azure.mgmt.keyvault.v2023_07_01.models.Permissions + :vartype permissions: ~azure.mgmt.keyvault.v2024_11_01.models.Permissions """ _validation = { @@ -70,7 +69,7 @@ def __init__( :paramtype application_id: str :keyword permissions: Permissions the identity has for keys, secrets and certificates. Required. - :paramtype permissions: ~azure.mgmt.keyvault.v2023_07_01.models.Permissions + :paramtype permissions: ~azure.mgmt.keyvault.v2024_11_01.models.Permissions """ super().__init__(**kwargs) self.tenant_id = tenant_id @@ -83,7 +82,7 @@ class Action(_serialization.Model): """Action. :ivar type: The type of action. Known values are: "rotate" and "notify". - :vartype type: str or ~azure.mgmt.keyvault.v2023_07_01.models.KeyRotationPolicyActionType + :vartype type: str or ~azure.mgmt.keyvault.v2024_11_01.models.KeyRotationPolicyActionType """ _attribute_map = { @@ -95,7 +94,7 @@ def __init__( ) -> None: """ :keyword type: The type of action. Known values are: "rotate" and "notify". - :paramtype type: str or ~azure.mgmt.keyvault.v2023_07_01.models.KeyRotationPolicyActionType + :paramtype type: str or ~azure.mgmt.keyvault.v2024_11_01.models.KeyRotationPolicyActionType """ super().__init__(**kwargs) self.type = type @@ -192,7 +191,7 @@ class CheckMhsmNameAvailabilityResult(_serialization.Model): :vartype name_available: bool :ivar reason: The reason that a managed hsm name could not be used. The reason element is only returned if NameAvailable is false. Known values are: "AccountNameInvalid" and "AlreadyExists". - :vartype reason: str or ~azure.mgmt.keyvault.v2023_07_01.models.Reason + :vartype reason: str or ~azure.mgmt.keyvault.v2024_11_01.models.Reason :ivar message: An error message explaining the Reason value in more detail. :vartype message: str """ @@ -228,7 +227,7 @@ class CheckNameAvailabilityResult(_serialization.Model): :vartype name_available: bool :ivar reason: The reason that a vault name could not be used. The Reason element is only returned if NameAvailable is false. Known values are: "AccountNameInvalid" and "AlreadyExists". - :vartype reason: str or ~azure.mgmt.keyvault.v2023_07_01.models.Reason + :vartype reason: str or ~azure.mgmt.keyvault.v2024_11_01.models.Reason :ivar message: An error message explaining the Reason value in more detail. :vartype message: str """ @@ -293,7 +292,7 @@ class DeletedManagedHsm(_serialization.Model): :ivar type: The resource type of the managed HSM Pool. :vartype type: str :ivar properties: Properties of the deleted managed HSM. - :vartype properties: ~azure.mgmt.keyvault.v2023_07_01.models.DeletedManagedHsmProperties + :vartype properties: ~azure.mgmt.keyvault.v2024_11_01.models.DeletedManagedHsmProperties """ _validation = { @@ -312,7 +311,7 @@ class DeletedManagedHsm(_serialization.Model): def __init__(self, *, properties: Optional["_models.DeletedManagedHsmProperties"] = None, **kwargs: Any) -> None: """ :keyword properties: Properties of the deleted managed HSM. - :paramtype properties: ~azure.mgmt.keyvault.v2023_07_01.models.DeletedManagedHsmProperties + :paramtype properties: ~azure.mgmt.keyvault.v2024_11_01.models.DeletedManagedHsmProperties """ super().__init__(**kwargs) self.id = None @@ -325,7 +324,7 @@ class DeletedManagedHsmListResult(_serialization.Model): """List of deleted managed HSM Pools. :ivar value: The list of deleted managed HSM Pools. - :vartype value: list[~azure.mgmt.keyvault.v2023_07_01.models.DeletedManagedHsm] + :vartype value: list[~azure.mgmt.keyvault.v2024_11_01.models.DeletedManagedHsm] :ivar next_link: The URL to get the next set of deleted managed HSM Pools. :vartype next_link: str """ @@ -344,7 +343,7 @@ def __init__( ) -> None: """ :keyword value: The list of deleted managed HSM Pools. - :paramtype value: list[~azure.mgmt.keyvault.v2023_07_01.models.DeletedManagedHsm] + :paramtype value: list[~azure.mgmt.keyvault.v2024_11_01.models.DeletedManagedHsm] :keyword next_link: The URL to get the next set of deleted managed HSM Pools. :paramtype next_link: str """ @@ -413,7 +412,7 @@ class DeletedVault(_serialization.Model): :ivar type: The resource type of the key vault. :vartype type: str :ivar properties: Properties of the vault. - :vartype properties: ~azure.mgmt.keyvault.v2023_07_01.models.DeletedVaultProperties + :vartype properties: ~azure.mgmt.keyvault.v2024_11_01.models.DeletedVaultProperties """ _validation = { @@ -432,7 +431,7 @@ class DeletedVault(_serialization.Model): def __init__(self, *, properties: Optional["_models.DeletedVaultProperties"] = None, **kwargs: Any) -> None: """ :keyword properties: Properties of the vault. - :paramtype properties: ~azure.mgmt.keyvault.v2023_07_01.models.DeletedVaultProperties + :paramtype properties: ~azure.mgmt.keyvault.v2024_11_01.models.DeletedVaultProperties """ super().__init__(**kwargs) self.id = None @@ -445,7 +444,7 @@ class DeletedVaultListResult(_serialization.Model): """List of vaults. :ivar value: The list of deleted vaults. - :vartype value: list[~azure.mgmt.keyvault.v2023_07_01.models.DeletedVault] + :vartype value: list[~azure.mgmt.keyvault.v2024_11_01.models.DeletedVault] :ivar next_link: The URL to get the next set of deleted vaults. :vartype next_link: str """ @@ -460,7 +459,7 @@ def __init__( ) -> None: """ :keyword value: The list of deleted vaults. - :paramtype value: list[~azure.mgmt.keyvault.v2023_07_01.models.DeletedVault] + :paramtype value: list[~azure.mgmt.keyvault.v2024_11_01.models.DeletedVault] :keyword next_link: The URL to get the next set of deleted vaults. :paramtype next_link: str """ @@ -568,7 +567,7 @@ class Error(_serialization.Model): :ivar message: The error message. :vartype message: str :ivar inner_error: The inner error, contains a more specific error code. - :vartype inner_error: ~azure.mgmt.keyvault.v2023_07_01.models.Error + :vartype inner_error: ~azure.mgmt.keyvault.v2024_11_01.models.Error """ _validation = { @@ -662,7 +661,7 @@ def __init__(self, **kwargs: Any) -> None: self.tags = None -class Key(Resource): # pylint: disable=too-many-instance-attributes +class Key(Resource): """The key resource. Variables are only populated by the server, and will be ignored when sending a request. @@ -678,27 +677,29 @@ class Key(Resource): # pylint: disable=too-many-instance-attributes :ivar tags: Tags assigned to the key vault resource. :vartype tags: dict[str, str] :ivar attributes: The attributes of the key. - :vartype attributes: ~azure.mgmt.keyvault.v2023_07_01.models.KeyAttributes + :vartype attributes: ~azure.mgmt.keyvault.v2024_11_01.models.KeyAttributes :ivar kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: "EC", "EC-HSM", "RSA", and "RSA-HSM". - :vartype kty: str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyType + :vartype kty: str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyType :ivar key_ops: - :vartype key_ops: list[str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyOperation] - :ivar key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. + :vartype key_ops: list[str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyOperation] + :ivar key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. Default for RSA + and RSA-HSM keys is 2048. Exception made for bring your own key (BYOK), key exchange keys + default to 4096. :vartype key_size: int - :ivar curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :vartype curve_name: str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyCurveName + :ivar curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Default + for EC and EC-HSM keys is P-256. Known values are: "P-256", "P-384", "P-521", and "P-256K". + :vartype curve_name: str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyCurveName :ivar key_uri: The URI to retrieve the current version of the key. :vartype key_uri: str :ivar key_uri_with_version: The URI to retrieve the specific version of the key. :vartype key_uri_with_version: str :ivar rotation_policy: Key rotation policy in response. It will be used for both output and input. Omitted if empty. - :vartype rotation_policy: ~azure.mgmt.keyvault.v2023_07_01.models.RotationPolicy + :vartype rotation_policy: ~azure.mgmt.keyvault.v2024_11_01.models.RotationPolicy :ivar release_policy: Key release policy in response. It will be used for both output and input. Omitted if empty. - :vartype release_policy: ~azure.mgmt.keyvault.v2023_07_01.models.KeyReleasePolicy + :vartype release_policy: ~azure.mgmt.keyvault.v2024_11_01.models.KeyReleasePolicy """ _validation = { @@ -742,23 +743,26 @@ def __init__( ) -> None: """ :keyword attributes: The attributes of the key. - :paramtype attributes: ~azure.mgmt.keyvault.v2023_07_01.models.KeyAttributes + :paramtype attributes: ~azure.mgmt.keyvault.v2024_11_01.models.KeyAttributes :keyword kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: "EC", "EC-HSM", "RSA", and "RSA-HSM". - :paramtype kty: str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyType + :paramtype kty: str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyType :keyword key_ops: - :paramtype key_ops: list[str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyOperation] - :keyword key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. + :paramtype key_ops: list[str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyOperation] + :keyword key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. Default for + RSA and RSA-HSM keys is 2048. Exception made for bring your own key (BYOK), key exchange keys + default to 4096. :paramtype key_size: int - :keyword curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :paramtype curve_name: str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyCurveName + :keyword curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. + Default for EC and EC-HSM keys is P-256. Known values are: "P-256", "P-384", "P-521", and + "P-256K". + :paramtype curve_name: str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyCurveName :keyword rotation_policy: Key rotation policy in response. It will be used for both output and input. Omitted if empty. - :paramtype rotation_policy: ~azure.mgmt.keyvault.v2023_07_01.models.RotationPolicy + :paramtype rotation_policy: ~azure.mgmt.keyvault.v2024_11_01.models.RotationPolicy :keyword release_policy: Key release policy in response. It will be used for both output and input. Omitted if empty. - :paramtype release_policy: ~azure.mgmt.keyvault.v2023_07_01.models.KeyReleasePolicy + :paramtype release_policy: ~azure.mgmt.keyvault.v2024_11_01.models.KeyReleasePolicy """ super().__init__(**kwargs) self.attributes = attributes @@ -792,7 +796,7 @@ class KeyAttributes(_serialization.Model): otherwise, only the system can purge the object at the end of the retention interval. Known values are: "Purgeable", "Recoverable+Purgeable", "Recoverable", and "Recoverable+ProtectedSubscription". - :vartype recovery_level: str or ~azure.mgmt.keyvault.v2023_07_01.models.DeletionRecoveryLevel + :vartype recovery_level: str or ~azure.mgmt.keyvault.v2024_11_01.models.DeletionRecoveryLevel :ivar exportable: Indicates if the private key can be exported. :vartype exportable: bool """ @@ -850,7 +854,7 @@ class KeyCreateParameters(_serialization.Model): :ivar tags: The tags that will be assigned to the key. :vartype tags: dict[str, str] :ivar properties: The properties of the key to be created. Required. - :vartype properties: ~azure.mgmt.keyvault.v2023_07_01.models.KeyProperties + :vartype properties: ~azure.mgmt.keyvault.v2024_11_01.models.KeyProperties """ _validation = { @@ -869,7 +873,7 @@ def __init__( :keyword tags: The tags that will be assigned to the key. :paramtype tags: dict[str, str] :keyword properties: The properties of the key to be created. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2023_07_01.models.KeyProperties + :paramtype properties: ~azure.mgmt.keyvault.v2024_11_01.models.KeyProperties """ super().__init__(**kwargs) self.tags = tags @@ -880,7 +884,7 @@ class KeyListResult(_serialization.Model): """The page of keys. :ivar value: The key resources. - :vartype value: list[~azure.mgmt.keyvault.v2023_07_01.models.Key] + :vartype value: list[~azure.mgmt.keyvault.v2024_11_01.models.Key] :ivar next_link: The URL to get the next page of keys. :vartype next_link: str """ @@ -895,7 +899,7 @@ def __init__( ) -> None: """ :keyword value: The key resources. - :paramtype value: list[~azure.mgmt.keyvault.v2023_07_01.models.Key] + :paramtype value: list[~azure.mgmt.keyvault.v2024_11_01.models.Key] :keyword next_link: The URL to get the next page of keys. :paramtype next_link: str """ @@ -910,27 +914,29 @@ class KeyProperties(_serialization.Model): Variables are only populated by the server, and will be ignored when sending a request. :ivar attributes: The attributes of the key. - :vartype attributes: ~azure.mgmt.keyvault.v2023_07_01.models.KeyAttributes + :vartype attributes: ~azure.mgmt.keyvault.v2024_11_01.models.KeyAttributes :ivar kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: "EC", "EC-HSM", "RSA", and "RSA-HSM". - :vartype kty: str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyType + :vartype kty: str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyType :ivar key_ops: - :vartype key_ops: list[str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyOperation] - :ivar key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. + :vartype key_ops: list[str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyOperation] + :ivar key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. Default for RSA + and RSA-HSM keys is 2048. Exception made for bring your own key (BYOK), key exchange keys + default to 4096. :vartype key_size: int - :ivar curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :vartype curve_name: str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyCurveName + :ivar curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Default + for EC and EC-HSM keys is P-256. Known values are: "P-256", "P-384", "P-521", and "P-256K". + :vartype curve_name: str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyCurveName :ivar key_uri: The URI to retrieve the current version of the key. :vartype key_uri: str :ivar key_uri_with_version: The URI to retrieve the specific version of the key. :vartype key_uri_with_version: str :ivar rotation_policy: Key rotation policy in response. It will be used for both output and input. Omitted if empty. - :vartype rotation_policy: ~azure.mgmt.keyvault.v2023_07_01.models.RotationPolicy + :vartype rotation_policy: ~azure.mgmt.keyvault.v2024_11_01.models.RotationPolicy :ivar release_policy: Key release policy in response. It will be used for both output and input. Omitted if empty. - :vartype release_policy: ~azure.mgmt.keyvault.v2023_07_01.models.KeyReleasePolicy + :vartype release_policy: ~azure.mgmt.keyvault.v2024_11_01.models.KeyReleasePolicy """ _validation = { @@ -964,23 +970,26 @@ def __init__( ) -> None: """ :keyword attributes: The attributes of the key. - :paramtype attributes: ~azure.mgmt.keyvault.v2023_07_01.models.KeyAttributes + :paramtype attributes: ~azure.mgmt.keyvault.v2024_11_01.models.KeyAttributes :keyword kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: "EC", "EC-HSM", "RSA", and "RSA-HSM". - :paramtype kty: str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyType + :paramtype kty: str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyType :keyword key_ops: - :paramtype key_ops: list[str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyOperation] - :keyword key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. + :paramtype key_ops: list[str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyOperation] + :keyword key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. Default for + RSA and RSA-HSM keys is 2048. Exception made for bring your own key (BYOK), key exchange keys + default to 4096. :paramtype key_size: int - :keyword curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :paramtype curve_name: str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyCurveName + :keyword curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. + Default for EC and EC-HSM keys is P-256. Known values are: "P-256", "P-384", "P-521", and + "P-256K". + :paramtype curve_name: str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyCurveName :keyword rotation_policy: Key rotation policy in response. It will be used for both output and input. Omitted if empty. - :paramtype rotation_policy: ~azure.mgmt.keyvault.v2023_07_01.models.RotationPolicy + :paramtype rotation_policy: ~azure.mgmt.keyvault.v2024_11_01.models.RotationPolicy :keyword release_policy: Key release policy in response. It will be used for both output and input. Omitted if empty. - :paramtype release_policy: ~azure.mgmt.keyvault.v2023_07_01.models.KeyReleasePolicy + :paramtype release_policy: ~azure.mgmt.keyvault.v2024_11_01.models.KeyReleasePolicy """ super().__init__(**kwargs) self.attributes = attributes @@ -1063,9 +1072,9 @@ class LifetimeAction(_serialization.Model): """LifetimeAction. :ivar trigger: The trigger of key rotation policy lifetimeAction. - :vartype trigger: ~azure.mgmt.keyvault.v2023_07_01.models.Trigger + :vartype trigger: ~azure.mgmt.keyvault.v2024_11_01.models.Trigger :ivar action: The action of key rotation policy lifetimeAction. - :vartype action: ~azure.mgmt.keyvault.v2023_07_01.models.Action + :vartype action: ~azure.mgmt.keyvault.v2024_11_01.models.Action """ _attribute_map = { @@ -1078,9 +1087,9 @@ def __init__( ) -> None: """ :keyword trigger: The trigger of key rotation policy lifetimeAction. - :paramtype trigger: ~azure.mgmt.keyvault.v2023_07_01.models.Trigger + :paramtype trigger: ~azure.mgmt.keyvault.v2024_11_01.models.Trigger :keyword action: The action of key rotation policy lifetimeAction. - :paramtype action: ~azure.mgmt.keyvault.v2023_07_01.models.Action + :paramtype action: ~azure.mgmt.keyvault.v2024_11_01.models.Action """ super().__init__(**kwargs) self.trigger = trigger @@ -1140,14 +1149,14 @@ class ManagedHsmResource(_serialization.Model): :ivar location: The supported Azure location where the managed HSM Pool should be created. :vartype location: str :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmSku + :vartype sku: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmSku :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar system_data: Metadata pertaining to creation and last modification of the key vault resource. - :vartype system_data: ~azure.mgmt.keyvault.v2023_07_01.models.SystemData + :vartype system_data: ~azure.mgmt.keyvault.v2024_11_01.models.SystemData :ivar identity: Managed service identity (system assigned and/or user assigned identities). - :vartype identity: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedServiceIdentity + :vartype identity: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedServiceIdentity """ _validation = { @@ -1181,11 +1190,11 @@ def __init__( :keyword location: The supported Azure location where the managed HSM Pool should be created. :paramtype location: str :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmSku + :paramtype sku: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmSku :keyword tags: Resource tags. :paramtype tags: dict[str, str] :keyword identity: Managed service identity (system assigned and/or user assigned identities). - :paramtype identity: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedServiceIdentity + :paramtype identity: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedServiceIdentity """ super().__init__(**kwargs) self.id = None @@ -1212,16 +1221,16 @@ class ManagedHsm(ManagedHsmResource): :ivar location: The supported Azure location where the managed HSM Pool should be created. :vartype location: str :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmSku + :vartype sku: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmSku :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar system_data: Metadata pertaining to creation and last modification of the key vault resource. - :vartype system_data: ~azure.mgmt.keyvault.v2023_07_01.models.SystemData + :vartype system_data: ~azure.mgmt.keyvault.v2024_11_01.models.SystemData :ivar identity: Managed service identity (system assigned and/or user assigned identities). - :vartype identity: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedServiceIdentity + :vartype identity: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedServiceIdentity :ivar properties: Properties of the managed HSM. - :vartype properties: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmProperties + :vartype properties: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmProperties """ _validation = { @@ -1257,13 +1266,13 @@ def __init__( :keyword location: The supported Azure location where the managed HSM Pool should be created. :paramtype location: str :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmSku + :paramtype sku: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmSku :keyword tags: Resource tags. :paramtype tags: dict[str, str] :keyword identity: Managed service identity (system assigned and/or user assigned identities). - :paramtype identity: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedServiceIdentity + :paramtype identity: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedServiceIdentity :keyword properties: Properties of the managed HSM. - :paramtype properties: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmProperties + :paramtype properties: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmProperties """ super().__init__(location=location, sku=sku, tags=tags, identity=identity, **kwargs) self.properties = properties @@ -1273,7 +1282,7 @@ class ManagedHsmAction(_serialization.Model): """ManagedHsmAction. :ivar type: The type of action. Known values are: "rotate" and "notify". - :vartype type: str or ~azure.mgmt.keyvault.v2023_07_01.models.KeyRotationPolicyActionType + :vartype type: str or ~azure.mgmt.keyvault.v2024_11_01.models.KeyRotationPolicyActionType """ _attribute_map = { @@ -1285,7 +1294,7 @@ def __init__( ) -> None: """ :keyword type: The type of action. Known values are: "rotate" and "notify". - :paramtype type: str or ~azure.mgmt.keyvault.v2023_07_01.models.KeyRotationPolicyActionType + :paramtype type: str or ~azure.mgmt.keyvault.v2024_11_01.models.KeyRotationPolicyActionType """ super().__init__(**kwargs) self.type = type @@ -1297,7 +1306,7 @@ class ManagedHsmError(_serialization.Model): Variables are only populated by the server, and will be ignored when sending a request. :ivar error: The server error. - :vartype error: ~azure.mgmt.keyvault.v2023_07_01.models.Error + :vartype error: ~azure.mgmt.keyvault.v2024_11_01.models.Error """ _validation = { @@ -1356,7 +1365,7 @@ def __init__(self, *, tags: Optional[Dict[str, str]] = None, **kwargs: Any) -> N self.tags = tags -class ManagedHsmKey(ProxyResourceWithoutSystemData): # pylint: disable=too-many-instance-attributes +class ManagedHsmKey(ProxyResourceWithoutSystemData): """The key resource. Variables are only populated by the server, and will be ignored when sending a request. @@ -1372,27 +1381,29 @@ class ManagedHsmKey(ProxyResourceWithoutSystemData): # pylint: disable=too-many :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar attributes: The attributes of the key. - :vartype attributes: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKeyAttributes + :vartype attributes: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKeyAttributes :ivar kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: "EC", "EC-HSM", "RSA", and "RSA-HSM". - :vartype kty: str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyType + :vartype kty: str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyType :ivar key_ops: - :vartype key_ops: list[str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyOperation] - :ivar key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. + :vartype key_ops: list[str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyOperation] + :ivar key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. Default for RSA + and RSA-HSM keys is 2048. Exception made for bring your own key (BYOK), key exchange keys + default to 4096. :vartype key_size: int - :ivar curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :vartype curve_name: str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyCurveName + :ivar curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Default + for EC and EC-HSM keys is P-256. Known values are: "P-256", "P-384", "P-521", and "P-256K". + :vartype curve_name: str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyCurveName :ivar key_uri: The URI to retrieve the current version of the key. :vartype key_uri: str :ivar key_uri_with_version: The URI to retrieve the specific version of the key. :vartype key_uri_with_version: str :ivar rotation_policy: Key rotation policy in response. It will be used for both output and input. Omitted if empty. - :vartype rotation_policy: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmRotationPolicy + :vartype rotation_policy: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmRotationPolicy :ivar release_policy: Key release policy in response. It will be used for both output and input. Omitted if empty. - :vartype release_policy: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKeyReleasePolicy + :vartype release_policy: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKeyReleasePolicy """ _validation = { @@ -1436,23 +1447,26 @@ def __init__( :keyword tags: Resource tags. :paramtype tags: dict[str, str] :keyword attributes: The attributes of the key. - :paramtype attributes: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKeyAttributes + :paramtype attributes: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKeyAttributes :keyword kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: "EC", "EC-HSM", "RSA", and "RSA-HSM". - :paramtype kty: str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyType + :paramtype kty: str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyType :keyword key_ops: - :paramtype key_ops: list[str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyOperation] - :keyword key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. + :paramtype key_ops: list[str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyOperation] + :keyword key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. Default for + RSA and RSA-HSM keys is 2048. Exception made for bring your own key (BYOK), key exchange keys + default to 4096. :paramtype key_size: int - :keyword curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :paramtype curve_name: str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyCurveName + :keyword curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. + Default for EC and EC-HSM keys is P-256. Known values are: "P-256", "P-384", "P-521", and + "P-256K". + :paramtype curve_name: str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyCurveName :keyword rotation_policy: Key rotation policy in response. It will be used for both output and input. Omitted if empty. - :paramtype rotation_policy: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmRotationPolicy + :paramtype rotation_policy: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmRotationPolicy :keyword release_policy: Key release policy in response. It will be used for both output and input. Omitted if empty. - :paramtype release_policy: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKeyReleasePolicy + :paramtype release_policy: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKeyReleasePolicy """ super().__init__(tags=tags, **kwargs) self.attributes = attributes @@ -1486,7 +1500,7 @@ class ManagedHsmKeyAttributes(_serialization.Model): otherwise, only the system can purge the object at the end of the retention interval. Known values are: "Purgeable", "Recoverable+Purgeable", "Recoverable", and "Recoverable+ProtectedSubscription". - :vartype recovery_level: str or ~azure.mgmt.keyvault.v2023_07_01.models.DeletionRecoveryLevel + :vartype recovery_level: str or ~azure.mgmt.keyvault.v2024_11_01.models.DeletionRecoveryLevel :ivar exportable: Indicates if the private key can be exported. :vartype exportable: bool """ @@ -1544,7 +1558,7 @@ class ManagedHsmKeyCreateParameters(_serialization.Model): :ivar tags: The tags that will be assigned to the key. :vartype tags: dict[str, str] :ivar properties: The properties of the key to be created. Required. - :vartype properties: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKeyProperties + :vartype properties: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKeyProperties """ _validation = { @@ -1563,7 +1577,7 @@ def __init__( :keyword tags: The tags that will be assigned to the key. :paramtype tags: dict[str, str] :keyword properties: The properties of the key to be created. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKeyProperties + :paramtype properties: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKeyProperties """ super().__init__(**kwargs) self.tags = tags @@ -1574,7 +1588,7 @@ class ManagedHsmKeyListResult(_serialization.Model): """The page of keys. :ivar value: The key resources. - :vartype value: list[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKey] + :vartype value: list[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKey] :ivar next_link: The URL to get the next page of keys. :vartype next_link: str """ @@ -1589,7 +1603,7 @@ def __init__( ) -> None: """ :keyword value: The key resources. - :paramtype value: list[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKey] + :paramtype value: list[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKey] :keyword next_link: The URL to get the next page of keys. :paramtype next_link: str """ @@ -1604,27 +1618,29 @@ class ManagedHsmKeyProperties(_serialization.Model): Variables are only populated by the server, and will be ignored when sending a request. :ivar attributes: The attributes of the key. - :vartype attributes: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKeyAttributes + :vartype attributes: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKeyAttributes :ivar kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: "EC", "EC-HSM", "RSA", and "RSA-HSM". - :vartype kty: str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyType + :vartype kty: str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyType :ivar key_ops: - :vartype key_ops: list[str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyOperation] - :ivar key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. + :vartype key_ops: list[str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyOperation] + :ivar key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. Default for RSA + and RSA-HSM keys is 2048. Exception made for bring your own key (BYOK), key exchange keys + default to 4096. :vartype key_size: int - :ivar curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :vartype curve_name: str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyCurveName + :ivar curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Default + for EC and EC-HSM keys is P-256. Known values are: "P-256", "P-384", "P-521", and "P-256K". + :vartype curve_name: str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyCurveName :ivar key_uri: The URI to retrieve the current version of the key. :vartype key_uri: str :ivar key_uri_with_version: The URI to retrieve the specific version of the key. :vartype key_uri_with_version: str :ivar rotation_policy: Key rotation policy in response. It will be used for both output and input. Omitted if empty. - :vartype rotation_policy: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmRotationPolicy + :vartype rotation_policy: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmRotationPolicy :ivar release_policy: Key release policy in response. It will be used for both output and input. Omitted if empty. - :vartype release_policy: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKeyReleasePolicy + :vartype release_policy: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKeyReleasePolicy """ _validation = { @@ -1658,23 +1674,26 @@ def __init__( ) -> None: """ :keyword attributes: The attributes of the key. - :paramtype attributes: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKeyAttributes + :paramtype attributes: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKeyAttributes :keyword kty: The type of the key. For valid values, see JsonWebKeyType. Known values are: "EC", "EC-HSM", "RSA", and "RSA-HSM". - :paramtype kty: str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyType + :paramtype kty: str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyType :keyword key_ops: - :paramtype key_ops: list[str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyOperation] - :keyword key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. + :paramtype key_ops: list[str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyOperation] + :keyword key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA. Default for + RSA and RSA-HSM keys is 2048. Exception made for bring your own key (BYOK), key exchange keys + default to 4096. :paramtype key_size: int - :keyword curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. Known - values are: "P-256", "P-384", "P-521", and "P-256K". - :paramtype curve_name: str or ~azure.mgmt.keyvault.v2023_07_01.models.JsonWebKeyCurveName + :keyword curve_name: The elliptic curve name. For valid values, see JsonWebKeyCurveName. + Default for EC and EC-HSM keys is P-256. Known values are: "P-256", "P-384", "P-521", and + "P-256K". + :paramtype curve_name: str or ~azure.mgmt.keyvault.v2024_11_01.models.JsonWebKeyCurveName :keyword rotation_policy: Key rotation policy in response. It will be used for both output and input. Omitted if empty. - :paramtype rotation_policy: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmRotationPolicy + :paramtype rotation_policy: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmRotationPolicy :keyword release_policy: Key release policy in response. It will be used for both output and input. Omitted if empty. - :paramtype release_policy: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKeyReleasePolicy + :paramtype release_policy: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKeyReleasePolicy """ super().__init__(**kwargs) self.attributes = attributes @@ -1757,9 +1776,9 @@ class ManagedHsmLifetimeAction(_serialization.Model): """ManagedHsmLifetimeAction. :ivar trigger: The trigger of key rotation policy lifetimeAction. - :vartype trigger: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmTrigger + :vartype trigger: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmTrigger :ivar action: The action of key rotation policy lifetimeAction. - :vartype action: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmAction + :vartype action: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmAction """ _attribute_map = { @@ -1776,9 +1795,9 @@ def __init__( ) -> None: """ :keyword trigger: The trigger of key rotation policy lifetimeAction. - :paramtype trigger: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmTrigger + :paramtype trigger: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmTrigger :keyword action: The action of key rotation policy lifetimeAction. - :paramtype action: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmAction + :paramtype action: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmAction """ super().__init__(**kwargs) self.trigger = trigger @@ -1789,7 +1808,7 @@ class ManagedHsmListResult(_serialization.Model): """List of managed HSM Pools. :ivar value: The list of managed HSM Pools. - :vartype value: list[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm] + :vartype value: list[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm] :ivar next_link: The URL to get the next set of managed HSM Pools. :vartype next_link: str """ @@ -1804,7 +1823,7 @@ def __init__( ) -> None: """ :keyword value: The list of managed HSM Pools. - :paramtype value: list[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm] + :paramtype value: list[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm] :keyword next_link: The URL to get the next set of managed HSM Pools. :paramtype next_link: str """ @@ -1813,7 +1832,7 @@ def __init__( self.next_link = next_link -class ManagedHsmProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes +class ManagedHsmProperties(_serialization.Model): """Properties of the managed HSM Pool. Variables are only populated by the server, and will be ignored when sending a request. @@ -1841,30 +1860,30 @@ class ManagedHsmProperties(_serialization.Model): # pylint: disable=too-many-in :vartype enable_purge_protection: bool :ivar create_mode: The create mode to indicate whether the resource is being created or is being recovered from a deleted resource. Known values are: "recover" and "default". - :vartype create_mode: str or ~azure.mgmt.keyvault.v2023_07_01.models.CreateMode + :vartype create_mode: str or ~azure.mgmt.keyvault.v2024_11_01.models.CreateMode :ivar status_message: Resource Status Message. :vartype status_message: str :ivar provisioning_state: Provisioning state. Known values are: "Succeeded", "Provisioning", "Failed", "Updating", "Deleting", "Activated", "SecurityDomainRestore", and "Restoring". - :vartype provisioning_state: str or ~azure.mgmt.keyvault.v2023_07_01.models.ProvisioningState + :vartype provisioning_state: str or ~azure.mgmt.keyvault.v2024_11_01.models.ProvisioningState :ivar network_acls: Rules governing the accessibility of the key vault from specific network locations. - :vartype network_acls: ~azure.mgmt.keyvault.v2023_07_01.models.MHSMNetworkRuleSet + :vartype network_acls: ~azure.mgmt.keyvault.v2024_11_01.models.MHSMNetworkRuleSet :ivar regions: List of all regions associated with the managed hsm pool. - :vartype regions: list[~azure.mgmt.keyvault.v2023_07_01.models.MHSMGeoReplicatedRegion] + :vartype regions: list[~azure.mgmt.keyvault.v2024_11_01.models.MHSMGeoReplicatedRegion] :ivar private_endpoint_connections: List of private endpoint connections associated with the managed hsm pool. :vartype private_endpoint_connections: - list[~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpointConnectionItem] + list[~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpointConnectionItem] :ivar public_network_access: Control permission to the managed HSM from public networks. Known values are: "Enabled" and "Disabled". :vartype public_network_access: str or - ~azure.mgmt.keyvault.v2023_07_01.models.PublicNetworkAccess + ~azure.mgmt.keyvault.v2024_11_01.models.PublicNetworkAccess :ivar scheduled_purge_date: The scheduled purge date in UTC. :vartype scheduled_purge_date: ~datetime.datetime :ivar security_domain_properties: Managed HSM security domain properties. :vartype security_domain_properties: - ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHSMSecurityDomainProperties + ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHSMSecurityDomainProperties """ _validation = { @@ -1933,16 +1952,16 @@ def __init__( :paramtype enable_purge_protection: bool :keyword create_mode: The create mode to indicate whether the resource is being created or is being recovered from a deleted resource. Known values are: "recover" and "default". - :paramtype create_mode: str or ~azure.mgmt.keyvault.v2023_07_01.models.CreateMode + :paramtype create_mode: str or ~azure.mgmt.keyvault.v2024_11_01.models.CreateMode :keyword network_acls: Rules governing the accessibility of the key vault from specific network locations. - :paramtype network_acls: ~azure.mgmt.keyvault.v2023_07_01.models.MHSMNetworkRuleSet + :paramtype network_acls: ~azure.mgmt.keyvault.v2024_11_01.models.MHSMNetworkRuleSet :keyword regions: List of all regions associated with the managed hsm pool. - :paramtype regions: list[~azure.mgmt.keyvault.v2023_07_01.models.MHSMGeoReplicatedRegion] + :paramtype regions: list[~azure.mgmt.keyvault.v2024_11_01.models.MHSMGeoReplicatedRegion] :keyword public_network_access: Control permission to the managed HSM from public networks. Known values are: "Enabled" and "Disabled". :paramtype public_network_access: str or - ~azure.mgmt.keyvault.v2023_07_01.models.PublicNetworkAccess + ~azure.mgmt.keyvault.v2024_11_01.models.PublicNetworkAccess """ super().__init__(**kwargs) self.tenant_id = tenant_id @@ -1967,10 +1986,10 @@ class ManagedHsmRotationPolicy(_serialization.Model): :ivar attributes: The attributes of key rotation policy. :vartype attributes: - ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKeyRotationPolicyAttributes + ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKeyRotationPolicyAttributes :ivar lifetime_actions: The lifetimeActions for key rotation action. :vartype lifetime_actions: - list[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmLifetimeAction] + list[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmLifetimeAction] """ _attribute_map = { @@ -1988,10 +2007,10 @@ def __init__( """ :keyword attributes: The attributes of key rotation policy. :paramtype attributes: - ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKeyRotationPolicyAttributes + ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKeyRotationPolicyAttributes :keyword lifetime_actions: The lifetimeActions for key rotation action. :paramtype lifetime_actions: - list[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmLifetimeAction] + list[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmLifetimeAction] """ super().__init__(**kwargs) self.attributes = attributes @@ -2005,7 +2024,7 @@ class ManagedHSMSecurityDomainProperties(_serialization.Model): :ivar activation_status: Activation Status. Known values are: "Active", "NotActivated", "Unknown", and "Failed". - :vartype activation_status: str or ~azure.mgmt.keyvault.v2023_07_01.models.ActivationStatus + :vartype activation_status: str or ~azure.mgmt.keyvault.v2024_11_01.models.ActivationStatus :ivar activation_status_message: Activation Status Message. :vartype activation_status_message: str """ @@ -2032,11 +2051,11 @@ class ManagedHsmSku(_serialization.Model): All required parameters must be populated in order to send to server. - :ivar family: SKU Family of the managed HSM Pool. "B" - :vartype family: str or ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmSkuFamily + :ivar family: SKU Family of the managed HSM Pool. Known values are: "B" and "C". + :vartype family: str or ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmSkuFamily :ivar name: SKU of the managed HSM Pool. Required. Known values are: "Standard_B1", - "Custom_B32", and "Custom_B6". - :vartype name: str or ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmSkuName + "Custom_B32", "Custom_B6", "Custom_C42", and "Custom_C10". + :vartype name: str or ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmSkuName """ _validation = { @@ -2057,11 +2076,11 @@ def __init__( **kwargs: Any ) -> None: """ - :keyword family: SKU Family of the managed HSM Pool. "B" - :paramtype family: str or ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmSkuFamily + :keyword family: SKU Family of the managed HSM Pool. Known values are: "B" and "C". + :paramtype family: str or ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmSkuFamily :keyword name: SKU of the managed HSM Pool. Required. Known values are: "Standard_B1", - "Custom_B32", and "Custom_B6". - :paramtype name: str or ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmSkuName + "Custom_B32", "Custom_B6", "Custom_C42", and "Custom_C10". + :paramtype name: str or ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmSkuName """ super().__init__(**kwargs) self.family = family @@ -2116,13 +2135,13 @@ class ManagedServiceIdentity(_serialization.Model): :ivar type: Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). Required. Known values are: "None", "SystemAssigned", "UserAssigned", and "SystemAssigned,UserAssigned". - :vartype type: str or ~azure.mgmt.keyvault.v2023_07_01.models.ManagedServiceIdentityType + :vartype type: str or ~azure.mgmt.keyvault.v2024_11_01.models.ManagedServiceIdentityType :ivar user_assigned_identities: The set of user assigned identities associated with the resource. The userAssignedIdentities dictionary keys will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}. # pylint: disable=line-too-long The dictionary values can be empty objects ({}) in requests. :vartype user_assigned_identities: dict[str, - ~azure.mgmt.keyvault.v2023_07_01.models.UserAssignedIdentity] + ~azure.mgmt.keyvault.v2024_11_01.models.UserAssignedIdentity] """ _validation = { @@ -2149,13 +2168,13 @@ def __init__( :keyword type: Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). Required. Known values are: "None", "SystemAssigned", "UserAssigned", and "SystemAssigned,UserAssigned". - :paramtype type: str or ~azure.mgmt.keyvault.v2023_07_01.models.ManagedServiceIdentityType + :paramtype type: str or ~azure.mgmt.keyvault.v2024_11_01.models.ManagedServiceIdentityType :keyword user_assigned_identities: The set of user assigned identities associated with the resource. The userAssignedIdentities dictionary keys will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}. # pylint: disable=line-too-long The dictionary values can be empty objects ({}) in requests. :paramtype user_assigned_identities: dict[str, - ~azure.mgmt.keyvault.v2023_07_01.models.UserAssignedIdentity] + ~azure.mgmt.keyvault.v2024_11_01.models.UserAssignedIdentity] """ super().__init__(**kwargs) self.principal_id = None @@ -2164,7 +2183,7 @@ def __init__( self.user_assigned_identities = user_assigned_identities -class MetricSpecification(_serialization.Model): # pylint: disable=too-many-instance-attributes +class MetricSpecification(_serialization.Model): """Metric specification of operation. :ivar name: Name of metric specification. @@ -2185,7 +2204,7 @@ class MetricSpecification(_serialization.Model): # pylint: disable=too-many-ins :ivar lock_aggregation_type: The metric lock aggregation type. :vartype lock_aggregation_type: str :ivar dimensions: The dimensions of metric. - :vartype dimensions: list[~azure.mgmt.keyvault.v2023_07_01.models.DimensionProperties] + :vartype dimensions: list[~azure.mgmt.keyvault.v2024_11_01.models.DimensionProperties] :ivar fill_gap_with_zero: Property to specify whether to fill gap with zero. :vartype fill_gap_with_zero: bool :ivar internal_metric_name: The internal metric name. @@ -2241,7 +2260,7 @@ def __init__( :keyword lock_aggregation_type: The metric lock aggregation type. :paramtype lock_aggregation_type: str :keyword dimensions: The dimensions of metric. - :paramtype dimensions: list[~azure.mgmt.keyvault.v2023_07_01.models.DimensionProperties] + :paramtype dimensions: list[~azure.mgmt.keyvault.v2024_11_01.models.DimensionProperties] :keyword fill_gap_with_zero: Property to specify whether to fill gap with zero. :paramtype fill_gap_with_zero: bool :keyword internal_metric_name: The internal metric name. @@ -2271,7 +2290,7 @@ class MHSMGeoReplicatedRegion(_serialization.Model): :ivar provisioning_state: Provisioning state of the geo replicated region. Known values are: "Preprovisioning", "Provisioning", "Succeeded", "Failed", "Deleting", and "Cleanup". :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2023_07_01.models.GeoReplicationRegionProvisioningState + ~azure.mgmt.keyvault.v2024_11_01.models.GeoReplicationRegionProvisioningState :ivar is_primary: A boolean value that indicates whether the region is the primary region or a secondary region. :vartype is_primary: bool @@ -2336,16 +2355,16 @@ class MHSMNetworkRuleSet(_serialization.Model): :ivar bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and "None". - :vartype bypass: str or ~azure.mgmt.keyvault.v2023_07_01.models.NetworkRuleBypassOptions + :vartype bypass: str or ~azure.mgmt.keyvault.v2024_11_01.models.NetworkRuleBypassOptions :ivar default_action: The default action when no rule from ipRules and from virtualNetworkRules match. This is only used after the bypass property has been evaluated. Known values are: "Allow" and "Deny". - :vartype default_action: str or ~azure.mgmt.keyvault.v2023_07_01.models.NetworkRuleAction + :vartype default_action: str or ~azure.mgmt.keyvault.v2024_11_01.models.NetworkRuleAction :ivar ip_rules: The list of IP address rules. - :vartype ip_rules: list[~azure.mgmt.keyvault.v2023_07_01.models.MHSMIPRule] + :vartype ip_rules: list[~azure.mgmt.keyvault.v2024_11_01.models.MHSMIPRule] :ivar virtual_network_rules: The list of virtual network rules. :vartype virtual_network_rules: - list[~azure.mgmt.keyvault.v2023_07_01.models.MHSMVirtualNetworkRule] + list[~azure.mgmt.keyvault.v2024_11_01.models.MHSMVirtualNetworkRule] """ _attribute_map = { @@ -2368,16 +2387,16 @@ def __init__( :keyword bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and "None". - :paramtype bypass: str or ~azure.mgmt.keyvault.v2023_07_01.models.NetworkRuleBypassOptions + :paramtype bypass: str or ~azure.mgmt.keyvault.v2024_11_01.models.NetworkRuleBypassOptions :keyword default_action: The default action when no rule from ipRules and from virtualNetworkRules match. This is only used after the bypass property has been evaluated. Known values are: "Allow" and "Deny". - :paramtype default_action: str or ~azure.mgmt.keyvault.v2023_07_01.models.NetworkRuleAction + :paramtype default_action: str or ~azure.mgmt.keyvault.v2024_11_01.models.NetworkRuleAction :keyword ip_rules: The list of IP address rules. - :paramtype ip_rules: list[~azure.mgmt.keyvault.v2023_07_01.models.MHSMIPRule] + :paramtype ip_rules: list[~azure.mgmt.keyvault.v2024_11_01.models.MHSMIPRule] :keyword virtual_network_rules: The list of virtual network rules. :paramtype virtual_network_rules: - list[~azure.mgmt.keyvault.v2023_07_01.models.MHSMVirtualNetworkRule] + list[~azure.mgmt.keyvault.v2024_11_01.models.MHSMVirtualNetworkRule] """ super().__init__(**kwargs) self.bypass = bypass @@ -2409,7 +2428,7 @@ def __init__(self, **kwargs: Any) -> None: self.id = None -class MHSMPrivateEndpointConnection(ManagedHsmResource): # pylint: disable=too-many-instance-attributes +class MHSMPrivateEndpointConnection(ManagedHsmResource): """Private endpoint connection resource. Variables are only populated by the server, and will be ignored when sending a request. @@ -2423,25 +2442,25 @@ class MHSMPrivateEndpointConnection(ManagedHsmResource): # pylint: disable=too- :ivar location: The supported Azure location where the managed HSM Pool should be created. :vartype location: str :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmSku + :vartype sku: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmSku :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar system_data: Metadata pertaining to creation and last modification of the key vault resource. - :vartype system_data: ~azure.mgmt.keyvault.v2023_07_01.models.SystemData + :vartype system_data: ~azure.mgmt.keyvault.v2024_11_01.models.SystemData :ivar identity: Managed service identity (system assigned and/or user assigned identities). - :vartype identity: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedServiceIdentity + :vartype identity: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedServiceIdentity :ivar etag: Modified whenever there is a change in the state of private endpoint connection. :vartype etag: str :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpoint + :vartype private_endpoint: ~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpoint :ivar private_link_service_connection_state: Approval state of the private link connection. :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateLinkServiceConnectionState + ~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateLinkServiceConnectionState :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnectionProvisioningState + ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnectionProvisioningState """ _validation = { @@ -2486,22 +2505,22 @@ def __init__( :keyword location: The supported Azure location where the managed HSM Pool should be created. :paramtype location: str :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmSku + :paramtype sku: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmSku :keyword tags: Resource tags. :paramtype tags: dict[str, str] :keyword identity: Managed service identity (system assigned and/or user assigned identities). - :paramtype identity: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedServiceIdentity + :paramtype identity: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedServiceIdentity :keyword etag: Modified whenever there is a change in the state of private endpoint connection. :paramtype etag: str :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: ~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpoint + :paramtype private_endpoint: ~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpoint :keyword private_link_service_connection_state: Approval state of the private link connection. :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateLinkServiceConnectionState + ~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateLinkServiceConnectionState :keyword provisioning_state: Provisioning state of the private endpoint connection. Known values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnectionProvisioningState + ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnectionProvisioningState """ super().__init__(location=location, sku=sku, tags=tags, identity=identity, **kwargs) self.etag = etag @@ -2518,14 +2537,14 @@ class MHSMPrivateEndpointConnectionItem(_serialization.Model): :ivar etag: Modified whenever there is a change in the state of private endpoint connection. :vartype etag: str :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpoint + :vartype private_endpoint: ~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpoint :ivar private_link_service_connection_state: Approval state of the private link connection. :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateLinkServiceConnectionState + ~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateLinkServiceConnectionState :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnectionProvisioningState + ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnectionProvisioningState """ _attribute_map = { @@ -2555,14 +2574,14 @@ def __init__( :keyword etag: Modified whenever there is a change in the state of private endpoint connection. :paramtype etag: str :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: ~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpoint + :paramtype private_endpoint: ~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpoint :keyword private_link_service_connection_state: Approval state of the private link connection. :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateLinkServiceConnectionState + ~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateLinkServiceConnectionState :keyword provisioning_state: Provisioning state of the private endpoint connection. Known values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnectionProvisioningState + ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnectionProvisioningState """ super().__init__(**kwargs) self.id = id @@ -2576,7 +2595,7 @@ class MHSMPrivateEndpointConnectionsListResult(_serialization.Model): """List of private endpoint connections associated with a managed HSM Pools. :ivar value: The private endpoint connection associated with a managed HSM Pools. - :vartype value: list[~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpointConnection] + :vartype value: list[~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpointConnection] :ivar next_link: The URL to get the next set of managed HSM Pools. :vartype next_link: str """ @@ -2595,7 +2614,7 @@ def __init__( ) -> None: """ :keyword value: The private endpoint connection associated with a managed HSM Pools. - :paramtype value: list[~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpointConnection] + :paramtype value: list[~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpointConnection] :keyword next_link: The URL to get the next set of managed HSM Pools. :paramtype next_link: str """ @@ -2604,7 +2623,7 @@ def __init__( self.next_link = next_link -class MHSMPrivateLinkResource(ManagedHsmResource): # pylint: disable=too-many-instance-attributes +class MHSMPrivateLinkResource(ManagedHsmResource): """A private link resource. Variables are only populated by the server, and will be ignored when sending a request. @@ -2618,14 +2637,14 @@ class MHSMPrivateLinkResource(ManagedHsmResource): # pylint: disable=too-many-i :ivar location: The supported Azure location where the managed HSM Pool should be created. :vartype location: str :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmSku + :vartype sku: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmSku :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar system_data: Metadata pertaining to creation and last modification of the key vault resource. - :vartype system_data: ~azure.mgmt.keyvault.v2023_07_01.models.SystemData + :vartype system_data: ~azure.mgmt.keyvault.v2024_11_01.models.SystemData :ivar identity: Managed service identity (system assigned and/or user assigned identities). - :vartype identity: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedServiceIdentity + :vartype identity: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedServiceIdentity :ivar group_id: Group identifier of private link resource. :vartype group_id: str :ivar required_members: Required member names of private link resource. @@ -2671,11 +2690,11 @@ def __init__( :keyword location: The supported Azure location where the managed HSM Pool should be created. :paramtype location: str :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmSku + :paramtype sku: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmSku :keyword tags: Resource tags. :paramtype tags: dict[str, str] :keyword identity: Managed service identity (system assigned and/or user assigned identities). - :paramtype identity: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedServiceIdentity + :paramtype identity: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedServiceIdentity :keyword required_zone_names: Required DNS zone names of the the private link resource. :paramtype required_zone_names: list[str] """ @@ -2689,7 +2708,7 @@ class MHSMPrivateLinkResourceListResult(_serialization.Model): """A list of private link resources. :ivar value: Array of private link resources. - :vartype value: list[~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateLinkResource] + :vartype value: list[~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateLinkResource] """ _attribute_map = { @@ -2699,7 +2718,7 @@ class MHSMPrivateLinkResourceListResult(_serialization.Model): def __init__(self, *, value: Optional[List["_models.MHSMPrivateLinkResource"]] = None, **kwargs: Any) -> None: """ :keyword value: Array of private link resources. - :paramtype value: list[~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateLinkResource] + :paramtype value: list[~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateLinkResource] """ super().__init__(**kwargs) self.value = value @@ -2711,12 +2730,12 @@ class MHSMPrivateLinkServiceConnectionState(_serialization.Model): :ivar status: Indicates whether the connection has been approved, rejected or removed by the key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". :vartype status: str or - ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointServiceConnectionStatus + ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointServiceConnectionStatus :ivar description: The reason for approval or rejection. :vartype description: str :ivar actions_required: A message indicating if changes on the service provider require any updates on the consumer. "None" - :vartype actions_required: str or ~azure.mgmt.keyvault.v2023_07_01.models.ActionsRequired + :vartype actions_required: str or ~azure.mgmt.keyvault.v2024_11_01.models.ActionsRequired """ _attribute_map = { @@ -2737,12 +2756,12 @@ def __init__( :keyword status: Indicates whether the connection has been approved, rejected or removed by the key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". :paramtype status: str or - ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointServiceConnectionStatus + ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointServiceConnectionStatus :keyword description: The reason for approval or rejection. :paramtype description: str :keyword actions_required: A message indicating if changes on the service provider require any updates on the consumer. "None" - :paramtype actions_required: str or ~azure.mgmt.keyvault.v2023_07_01.models.ActionsRequired + :paramtype actions_required: str or ~azure.mgmt.keyvault.v2024_11_01.models.ActionsRequired """ super().__init__(**kwargs) self.status = status @@ -2754,7 +2773,7 @@ class MHSMRegionsListResult(_serialization.Model): """List of regions associated with a managed HSM Pools. :ivar value: The region associated with a managed HSM Pools. - :vartype value: list[~azure.mgmt.keyvault.v2023_07_01.models.MHSMGeoReplicatedRegion] + :vartype value: list[~azure.mgmt.keyvault.v2024_11_01.models.MHSMGeoReplicatedRegion] :ivar next_link: The URL to get the next set of managed HSM Pools. :vartype next_link: str """ @@ -2773,7 +2792,7 @@ def __init__( ) -> None: """ :keyword value: The region associated with a managed HSM Pools. - :paramtype value: list[~azure.mgmt.keyvault.v2023_07_01.models.MHSMGeoReplicatedRegion] + :paramtype value: list[~azure.mgmt.keyvault.v2024_11_01.models.MHSMGeoReplicatedRegion] :keyword next_link: The URL to get the next set of managed HSM Pools. :paramtype next_link: str """ @@ -2818,16 +2837,16 @@ class NetworkRuleSet(_serialization.Model): :ivar bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and "None". - :vartype bypass: str or ~azure.mgmt.keyvault.v2023_07_01.models.NetworkRuleBypassOptions + :vartype bypass: str or ~azure.mgmt.keyvault.v2024_11_01.models.NetworkRuleBypassOptions :ivar default_action: The default action when no rule from ipRules and from virtualNetworkRules match. This is only used after the bypass property has been evaluated. Known values are: "Allow" and "Deny". - :vartype default_action: str or ~azure.mgmt.keyvault.v2023_07_01.models.NetworkRuleAction + :vartype default_action: str or ~azure.mgmt.keyvault.v2024_11_01.models.NetworkRuleAction :ivar ip_rules: The list of IP address rules. - :vartype ip_rules: list[~azure.mgmt.keyvault.v2023_07_01.models.IPRule] + :vartype ip_rules: list[~azure.mgmt.keyvault.v2024_11_01.models.IPRule] :ivar virtual_network_rules: The list of virtual network rules. :vartype virtual_network_rules: - list[~azure.mgmt.keyvault.v2023_07_01.models.VirtualNetworkRule] + list[~azure.mgmt.keyvault.v2024_11_01.models.VirtualNetworkRule] """ _attribute_map = { @@ -2850,16 +2869,16 @@ def __init__( :keyword bypass: Tells what traffic can bypass network rules. This can be 'AzureServices' or 'None'. If not specified the default is 'AzureServices'. Known values are: "AzureServices" and "None". - :paramtype bypass: str or ~azure.mgmt.keyvault.v2023_07_01.models.NetworkRuleBypassOptions + :paramtype bypass: str or ~azure.mgmt.keyvault.v2024_11_01.models.NetworkRuleBypassOptions :keyword default_action: The default action when no rule from ipRules and from virtualNetworkRules match. This is only used after the bypass property has been evaluated. Known values are: "Allow" and "Deny". - :paramtype default_action: str or ~azure.mgmt.keyvault.v2023_07_01.models.NetworkRuleAction + :paramtype default_action: str or ~azure.mgmt.keyvault.v2024_11_01.models.NetworkRuleAction :keyword ip_rules: The list of IP address rules. - :paramtype ip_rules: list[~azure.mgmt.keyvault.v2023_07_01.models.IPRule] + :paramtype ip_rules: list[~azure.mgmt.keyvault.v2024_11_01.models.IPRule] :keyword virtual_network_rules: The list of virtual network rules. :paramtype virtual_network_rules: - list[~azure.mgmt.keyvault.v2023_07_01.models.VirtualNetworkRule] + list[~azure.mgmt.keyvault.v2024_11_01.models.VirtualNetworkRule] """ super().__init__(**kwargs) self.bypass = bypass @@ -2874,13 +2893,13 @@ class Operation(_serialization.Model): :ivar name: Operation name: {provider}/{resource}/{operation}. :vartype name: str :ivar display: Display metadata associated with the operation. - :vartype display: ~azure.mgmt.keyvault.v2023_07_01.models.OperationDisplay + :vartype display: ~azure.mgmt.keyvault.v2024_11_01.models.OperationDisplay :ivar origin: The origin of operations. :vartype origin: str :ivar is_data_action: Property to specify whether the action is a data action. :vartype is_data_action: bool :ivar service_specification: One property of operation, include metric specifications. - :vartype service_specification: ~azure.mgmt.keyvault.v2023_07_01.models.ServiceSpecification + :vartype service_specification: ~azure.mgmt.keyvault.v2024_11_01.models.ServiceSpecification """ _attribute_map = { @@ -2905,13 +2924,13 @@ def __init__( :keyword name: Operation name: {provider}/{resource}/{operation}. :paramtype name: str :keyword display: Display metadata associated with the operation. - :paramtype display: ~azure.mgmt.keyvault.v2023_07_01.models.OperationDisplay + :paramtype display: ~azure.mgmt.keyvault.v2024_11_01.models.OperationDisplay :keyword origin: The origin of operations. :paramtype origin: str :keyword is_data_action: Property to specify whether the action is a data action. :paramtype is_data_action: bool :keyword service_specification: One property of operation, include metric specifications. - :paramtype service_specification: ~azure.mgmt.keyvault.v2023_07_01.models.ServiceSpecification + :paramtype service_specification: ~azure.mgmt.keyvault.v2024_11_01.models.ServiceSpecification """ super().__init__(**kwargs) self.name = name @@ -2972,7 +2991,7 @@ class OperationListResult(_serialization.Model): link to get the next set of results. :ivar value: List of Storage operations supported by the Storage resource provider. - :vartype value: list[~azure.mgmt.keyvault.v2023_07_01.models.Operation] + :vartype value: list[~azure.mgmt.keyvault.v2024_11_01.models.Operation] :ivar next_link: The URL to get the next set of operations. :vartype next_link: str """ @@ -2987,7 +3006,7 @@ def __init__( ) -> None: """ :keyword value: List of Storage operations supported by the Storage resource provider. - :paramtype value: list[~azure.mgmt.keyvault.v2023_07_01.models.Operation] + :paramtype value: list[~azure.mgmt.keyvault.v2024_11_01.models.Operation] :keyword next_link: The URL to get the next set of operations. :paramtype next_link: str """ @@ -3000,14 +3019,14 @@ class Permissions(_serialization.Model): """Permissions the identity has for keys, secrets, certificates and storage. :ivar keys: Permissions to keys. - :vartype keys: list[str or ~azure.mgmt.keyvault.v2023_07_01.models.KeyPermissions] + :vartype keys: list[str or ~azure.mgmt.keyvault.v2024_11_01.models.KeyPermissions] :ivar secrets: Permissions to secrets. - :vartype secrets: list[str or ~azure.mgmt.keyvault.v2023_07_01.models.SecretPermissions] + :vartype secrets: list[str or ~azure.mgmt.keyvault.v2024_11_01.models.SecretPermissions] :ivar certificates: Permissions to certificates. :vartype certificates: list[str or - ~azure.mgmt.keyvault.v2023_07_01.models.CertificatePermissions] + ~azure.mgmt.keyvault.v2024_11_01.models.CertificatePermissions] :ivar storage: Permissions to storage accounts. - :vartype storage: list[str or ~azure.mgmt.keyvault.v2023_07_01.models.StoragePermissions] + :vartype storage: list[str or ~azure.mgmt.keyvault.v2024_11_01.models.StoragePermissions] """ _attribute_map = { @@ -3028,14 +3047,14 @@ def __init__( ) -> None: """ :keyword keys: Permissions to keys. - :paramtype keys: list[str or ~azure.mgmt.keyvault.v2023_07_01.models.KeyPermissions] + :paramtype keys: list[str or ~azure.mgmt.keyvault.v2024_11_01.models.KeyPermissions] :keyword secrets: Permissions to secrets. - :paramtype secrets: list[str or ~azure.mgmt.keyvault.v2023_07_01.models.SecretPermissions] + :paramtype secrets: list[str or ~azure.mgmt.keyvault.v2024_11_01.models.SecretPermissions] :keyword certificates: Permissions to certificates. :paramtype certificates: list[str or - ~azure.mgmt.keyvault.v2023_07_01.models.CertificatePermissions] + ~azure.mgmt.keyvault.v2024_11_01.models.CertificatePermissions] :keyword storage: Permissions to storage accounts. - :paramtype storage: list[str or ~azure.mgmt.keyvault.v2023_07_01.models.StoragePermissions] + :paramtype storage: list[str or ~azure.mgmt.keyvault.v2024_11_01.models.StoragePermissions] """ super().__init__(**kwargs) self.keys = keys @@ -3085,14 +3104,14 @@ class PrivateEndpointConnection(Resource): :ivar etag: Modified whenever there is a change in the state of private endpoint connection. :vartype etag: str :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpoint + :vartype private_endpoint: ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpoint :ivar private_link_service_connection_state: Approval state of the private link connection. :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2023_07_01.models.PrivateLinkServiceConnectionState + ~azure.mgmt.keyvault.v2024_11_01.models.PrivateLinkServiceConnectionState :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnectionProvisioningState + ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnectionProvisioningState """ _validation = { @@ -3131,14 +3150,14 @@ def __init__( :keyword etag: Modified whenever there is a change in the state of private endpoint connection. :paramtype etag: str :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpoint + :paramtype private_endpoint: ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpoint :keyword private_link_service_connection_state: Approval state of the private link connection. :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2023_07_01.models.PrivateLinkServiceConnectionState + ~azure.mgmt.keyvault.v2024_11_01.models.PrivateLinkServiceConnectionState :keyword provisioning_state: Provisioning state of the private endpoint connection. Known values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnectionProvisioningState + ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnectionProvisioningState """ super().__init__(**kwargs) self.etag = etag @@ -3155,14 +3174,14 @@ class PrivateEndpointConnectionItem(_serialization.Model): :ivar etag: Modified whenever there is a change in the state of private endpoint connection. :vartype etag: str :ivar private_endpoint: Properties of the private endpoint object. - :vartype private_endpoint: ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpoint + :vartype private_endpoint: ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpoint :ivar private_link_service_connection_state: Approval state of the private link connection. :vartype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2023_07_01.models.PrivateLinkServiceConnectionState + ~azure.mgmt.keyvault.v2024_11_01.models.PrivateLinkServiceConnectionState :ivar provisioning_state: Provisioning state of the private endpoint connection. Known values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnectionProvisioningState + ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnectionProvisioningState """ _attribute_map = { @@ -3192,14 +3211,14 @@ def __init__( :keyword etag: Modified whenever there is a change in the state of private endpoint connection. :paramtype etag: str :keyword private_endpoint: Properties of the private endpoint object. - :paramtype private_endpoint: ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpoint + :paramtype private_endpoint: ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpoint :keyword private_link_service_connection_state: Approval state of the private link connection. :paramtype private_link_service_connection_state: - ~azure.mgmt.keyvault.v2023_07_01.models.PrivateLinkServiceConnectionState + ~azure.mgmt.keyvault.v2024_11_01.models.PrivateLinkServiceConnectionState :keyword provisioning_state: Provisioning state of the private endpoint connection. Known values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnectionProvisioningState + ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnectionProvisioningState """ super().__init__(**kwargs) self.id = id @@ -3213,7 +3232,7 @@ class PrivateEndpointConnectionListResult(_serialization.Model): """List of private endpoint connections. :ivar value: The list of private endpoint connections. - :vartype value: list[~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnection] + :vartype value: list[~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnection] :ivar next_link: The URL to get the next set of private endpoint connections. :vartype next_link: str """ @@ -3232,7 +3251,7 @@ def __init__( ) -> None: """ :keyword value: The list of private endpoint connections. - :paramtype value: list[~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnection] + :paramtype value: list[~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnection] :keyword next_link: The URL to get the next set of private endpoint connections. :paramtype next_link: str """ @@ -3300,7 +3319,7 @@ class PrivateLinkResourceListResult(_serialization.Model): """A list of private link resources. :ivar value: Array of private link resources. - :vartype value: list[~azure.mgmt.keyvault.v2023_07_01.models.PrivateLinkResource] + :vartype value: list[~azure.mgmt.keyvault.v2024_11_01.models.PrivateLinkResource] """ _attribute_map = { @@ -3310,7 +3329,7 @@ class PrivateLinkResourceListResult(_serialization.Model): def __init__(self, *, value: Optional[List["_models.PrivateLinkResource"]] = None, **kwargs: Any) -> None: """ :keyword value: Array of private link resources. - :paramtype value: list[~azure.mgmt.keyvault.v2023_07_01.models.PrivateLinkResource] + :paramtype value: list[~azure.mgmt.keyvault.v2024_11_01.models.PrivateLinkResource] """ super().__init__(**kwargs) self.value = value @@ -3322,12 +3341,12 @@ class PrivateLinkServiceConnectionState(_serialization.Model): :ivar status: Indicates whether the connection has been approved, rejected or removed by the key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". :vartype status: str or - ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointServiceConnectionStatus + ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointServiceConnectionStatus :ivar description: The reason for approval or rejection. :vartype description: str :ivar actions_required: A message indicating if changes on the service provider require any updates on the consumer. "None" - :vartype actions_required: str or ~azure.mgmt.keyvault.v2023_07_01.models.ActionsRequired + :vartype actions_required: str or ~azure.mgmt.keyvault.v2024_11_01.models.ActionsRequired """ _attribute_map = { @@ -3348,12 +3367,12 @@ def __init__( :keyword status: Indicates whether the connection has been approved, rejected or removed by the key vault owner. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". :paramtype status: str or - ~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointServiceConnectionStatus + ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointServiceConnectionStatus :keyword description: The reason for approval or rejection. :paramtype description: str :keyword actions_required: A message indicating if changes on the service provider require any updates on the consumer. "None" - :paramtype actions_required: str or ~azure.mgmt.keyvault.v2023_07_01.models.ActionsRequired + :paramtype actions_required: str or ~azure.mgmt.keyvault.v2024_11_01.models.ActionsRequired """ super().__init__(**kwargs) self.status = status @@ -3365,7 +3384,7 @@ class ResourceListResult(_serialization.Model): """List of vault resources. :ivar value: The list of vault resources. - :vartype value: list[~azure.mgmt.keyvault.v2023_07_01.models.Resource] + :vartype value: list[~azure.mgmt.keyvault.v2024_11_01.models.Resource] :ivar next_link: The URL to get the next set of vault resources. :vartype next_link: str """ @@ -3380,7 +3399,7 @@ def __init__( ) -> None: """ :keyword value: The list of vault resources. - :paramtype value: list[~azure.mgmt.keyvault.v2023_07_01.models.Resource] + :paramtype value: list[~azure.mgmt.keyvault.v2024_11_01.models.Resource] :keyword next_link: The URL to get the next set of vault resources. :paramtype next_link: str """ @@ -3393,9 +3412,9 @@ class RotationPolicy(_serialization.Model): """RotationPolicy. :ivar attributes: The attributes of key rotation policy. - :vartype attributes: ~azure.mgmt.keyvault.v2023_07_01.models.KeyRotationPolicyAttributes + :vartype attributes: ~azure.mgmt.keyvault.v2024_11_01.models.KeyRotationPolicyAttributes :ivar lifetime_actions: The lifetimeActions for key rotation action. - :vartype lifetime_actions: list[~azure.mgmt.keyvault.v2023_07_01.models.LifetimeAction] + :vartype lifetime_actions: list[~azure.mgmt.keyvault.v2024_11_01.models.LifetimeAction] """ _attribute_map = { @@ -3412,9 +3431,9 @@ def __init__( ) -> None: """ :keyword attributes: The attributes of key rotation policy. - :paramtype attributes: ~azure.mgmt.keyvault.v2023_07_01.models.KeyRotationPolicyAttributes + :paramtype attributes: ~azure.mgmt.keyvault.v2024_11_01.models.KeyRotationPolicyAttributes :keyword lifetime_actions: The lifetimeActions for key rotation action. - :paramtype lifetime_actions: list[~azure.mgmt.keyvault.v2023_07_01.models.LifetimeAction] + :paramtype lifetime_actions: list[~azure.mgmt.keyvault.v2024_11_01.models.LifetimeAction] """ super().__init__(**kwargs) self.attributes = attributes @@ -3439,7 +3458,7 @@ class Secret(Resource): :ivar tags: Tags assigned to the key vault resource. :vartype tags: dict[str, str] :ivar properties: Properties of the secret. Required. - :vartype properties: ~azure.mgmt.keyvault.v2023_07_01.models.SecretProperties + :vartype properties: ~azure.mgmt.keyvault.v2024_11_01.models.SecretProperties """ _validation = { @@ -3463,7 +3482,7 @@ class Secret(Resource): def __init__(self, *, properties: "_models.SecretProperties", **kwargs: Any) -> None: """ :keyword properties: Properties of the secret. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2023_07_01.models.SecretProperties + :paramtype properties: ~azure.mgmt.keyvault.v2024_11_01.models.SecretProperties """ super().__init__(**kwargs) self.properties = properties @@ -3495,7 +3514,7 @@ class SecretCreateOrUpdateParameters(_serialization.Model): :ivar tags: The tags that will be assigned to the secret. :vartype tags: dict[str, str] :ivar properties: Properties of the secret. Required. - :vartype properties: ~azure.mgmt.keyvault.v2023_07_01.models.SecretProperties + :vartype properties: ~azure.mgmt.keyvault.v2024_11_01.models.SecretProperties """ _validation = { @@ -3514,7 +3533,7 @@ def __init__( :keyword tags: The tags that will be assigned to the secret. :paramtype tags: dict[str, str] :keyword properties: Properties of the secret. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2023_07_01.models.SecretProperties + :paramtype properties: ~azure.mgmt.keyvault.v2024_11_01.models.SecretProperties """ super().__init__(**kwargs) self.tags = tags @@ -3525,7 +3544,7 @@ class SecretListResult(_serialization.Model): """List of secrets. :ivar value: The list of secrets. - :vartype value: list[~azure.mgmt.keyvault.v2023_07_01.models.Secret] + :vartype value: list[~azure.mgmt.keyvault.v2024_11_01.models.Secret] :ivar next_link: The URL to get the next set of secrets. :vartype next_link: str """ @@ -3540,7 +3559,7 @@ def __init__( ) -> None: """ :keyword value: The list of secrets. - :paramtype value: list[~azure.mgmt.keyvault.v2023_07_01.models.Secret] + :paramtype value: list[~azure.mgmt.keyvault.v2024_11_01.models.Secret] :keyword next_link: The URL to get the next set of secrets. :paramtype next_link: str """ @@ -3555,7 +3574,7 @@ class SecretPatchParameters(_serialization.Model): :ivar tags: The tags that will be assigned to the secret. :vartype tags: dict[str, str] :ivar properties: Properties of the secret. - :vartype properties: ~azure.mgmt.keyvault.v2023_07_01.models.SecretPatchProperties + :vartype properties: ~azure.mgmt.keyvault.v2024_11_01.models.SecretPatchProperties """ _attribute_map = { @@ -3574,7 +3593,7 @@ def __init__( :keyword tags: The tags that will be assigned to the secret. :paramtype tags: dict[str, str] :keyword properties: Properties of the secret. - :paramtype properties: ~azure.mgmt.keyvault.v2023_07_01.models.SecretPatchProperties + :paramtype properties: ~azure.mgmt.keyvault.v2024_11_01.models.SecretPatchProperties """ super().__init__(**kwargs) self.tags = tags @@ -3589,7 +3608,7 @@ class SecretPatchProperties(_serialization.Model): :ivar content_type: The content type of the secret. :vartype content_type: str :ivar attributes: The attributes of the secret. - :vartype attributes: ~azure.mgmt.keyvault.v2023_07_01.models.SecretAttributes + :vartype attributes: ~azure.mgmt.keyvault.v2024_11_01.models.SecretAttributes """ _attribute_map = { @@ -3612,7 +3631,7 @@ def __init__( :keyword content_type: The content type of the secret. :paramtype content_type: str :keyword attributes: The attributes of the secret. - :paramtype attributes: ~azure.mgmt.keyvault.v2023_07_01.models.SecretAttributes + :paramtype attributes: ~azure.mgmt.keyvault.v2024_11_01.models.SecretAttributes """ super().__init__(**kwargs) self.value = value @@ -3632,7 +3651,7 @@ class SecretProperties(_serialization.Model): :ivar content_type: The content type of the secret. :vartype content_type: str :ivar attributes: The attributes of the secret. - :vartype attributes: ~azure.mgmt.keyvault.v2023_07_01.models.SecretAttributes + :vartype attributes: ~azure.mgmt.keyvault.v2024_11_01.models.SecretAttributes :ivar secret_uri: The URI to retrieve the current version of the secret. :vartype secret_uri: str :ivar secret_uri_with_version: The URI to retrieve the specific version of the secret. @@ -3668,7 +3687,7 @@ def __init__( :keyword content_type: The content type of the secret. :paramtype content_type: str :keyword attributes: The attributes of the secret. - :paramtype attributes: ~azure.mgmt.keyvault.v2023_07_01.models.SecretAttributes + :paramtype attributes: ~azure.mgmt.keyvault.v2024_11_01.models.SecretAttributes """ super().__init__(**kwargs) self.value = value @@ -3682,10 +3701,10 @@ class ServiceSpecification(_serialization.Model): """One property of operation, include log specifications. :ivar log_specifications: Log specifications of operation. - :vartype log_specifications: list[~azure.mgmt.keyvault.v2023_07_01.models.LogSpecification] + :vartype log_specifications: list[~azure.mgmt.keyvault.v2024_11_01.models.LogSpecification] :ivar metric_specifications: Metric specifications of operation. :vartype metric_specifications: - list[~azure.mgmt.keyvault.v2023_07_01.models.MetricSpecification] + list[~azure.mgmt.keyvault.v2024_11_01.models.MetricSpecification] """ _attribute_map = { @@ -3702,10 +3721,10 @@ def __init__( ) -> None: """ :keyword log_specifications: Log specifications of operation. - :paramtype log_specifications: list[~azure.mgmt.keyvault.v2023_07_01.models.LogSpecification] + :paramtype log_specifications: list[~azure.mgmt.keyvault.v2024_11_01.models.LogSpecification] :keyword metric_specifications: Metric specifications of operation. :paramtype metric_specifications: - list[~azure.mgmt.keyvault.v2023_07_01.models.MetricSpecification] + list[~azure.mgmt.keyvault.v2024_11_01.models.MetricSpecification] """ super().__init__(**kwargs) self.log_specifications = log_specifications @@ -3718,10 +3737,10 @@ class Sku(_serialization.Model): All required parameters must be populated in order to send to server. :ivar family: SKU family name. "A" - :vartype family: str or ~azure.mgmt.keyvault.v2023_07_01.models.SkuFamily + :vartype family: str or ~azure.mgmt.keyvault.v2024_11_01.models.SkuFamily :ivar name: SKU name to specify whether the key vault is a standard vault or a premium vault. Required. Known values are: "standard" and "premium". - :vartype name: str or ~azure.mgmt.keyvault.v2023_07_01.models.SkuName + :vartype name: str or ~azure.mgmt.keyvault.v2024_11_01.models.SkuName """ _validation = { @@ -3739,10 +3758,10 @@ def __init__( ) -> None: """ :keyword family: SKU family name. "A" - :paramtype family: str or ~azure.mgmt.keyvault.v2023_07_01.models.SkuFamily + :paramtype family: str or ~azure.mgmt.keyvault.v2024_11_01.models.SkuFamily :keyword name: SKU name to specify whether the key vault is a standard vault or a premium vault. Required. Known values are: "standard" and "premium". - :paramtype name: str or ~azure.mgmt.keyvault.v2023_07_01.models.SkuName + :paramtype name: str or ~azure.mgmt.keyvault.v2024_11_01.models.SkuName """ super().__init__(**kwargs) self.family = family @@ -3756,14 +3775,14 @@ class SystemData(_serialization.Model): :vartype created_by: str :ivar created_by_type: The type of identity that created the key vault resource. Known values are: "User", "Application", "ManagedIdentity", and "Key". - :vartype created_by_type: str or ~azure.mgmt.keyvault.v2023_07_01.models.IdentityType + :vartype created_by_type: str or ~azure.mgmt.keyvault.v2024_11_01.models.IdentityType :ivar created_at: The timestamp of the key vault resource creation (UTC). :vartype created_at: ~datetime.datetime :ivar last_modified_by: The identity that last modified the key vault resource. :vartype last_modified_by: str :ivar last_modified_by_type: The type of identity that last modified the key vault resource. Known values are: "User", "Application", "ManagedIdentity", and "Key". - :vartype last_modified_by_type: str or ~azure.mgmt.keyvault.v2023_07_01.models.IdentityType + :vartype last_modified_by_type: str or ~azure.mgmt.keyvault.v2024_11_01.models.IdentityType :ivar last_modified_at: The timestamp of the key vault resource last modification (UTC). :vartype last_modified_at: ~datetime.datetime """ @@ -3793,14 +3812,14 @@ def __init__( :paramtype created_by: str :keyword created_by_type: The type of identity that created the key vault resource. Known values are: "User", "Application", "ManagedIdentity", and "Key". - :paramtype created_by_type: str or ~azure.mgmt.keyvault.v2023_07_01.models.IdentityType + :paramtype created_by_type: str or ~azure.mgmt.keyvault.v2024_11_01.models.IdentityType :keyword created_at: The timestamp of the key vault resource creation (UTC). :paramtype created_at: ~datetime.datetime :keyword last_modified_by: The identity that last modified the key vault resource. :paramtype last_modified_by: str :keyword last_modified_by_type: The type of identity that last modified the key vault resource. Known values are: "User", "Application", "ManagedIdentity", and "Key". - :paramtype last_modified_by_type: str or ~azure.mgmt.keyvault.v2023_07_01.models.IdentityType + :paramtype last_modified_by_type: str or ~azure.mgmt.keyvault.v2024_11_01.models.IdentityType :keyword last_modified_at: The timestamp of the key vault resource last modification (UTC). :paramtype last_modified_at: ~datetime.datetime """ @@ -3891,9 +3910,9 @@ class Vault(_serialization.Model): :ivar tags: Tags assigned to the key vault resource. :vartype tags: dict[str, str] :ivar system_data: System metadata for the key vault. - :vartype system_data: ~azure.mgmt.keyvault.v2023_07_01.models.SystemData + :vartype system_data: ~azure.mgmt.keyvault.v2024_11_01.models.SystemData :ivar properties: Properties of the vault. Required. - :vartype properties: ~azure.mgmt.keyvault.v2023_07_01.models.VaultProperties + :vartype properties: ~azure.mgmt.keyvault.v2024_11_01.models.VaultProperties """ _validation = { @@ -3928,7 +3947,7 @@ def __init__( :keyword tags: Tags assigned to the key vault resource. :paramtype tags: dict[str, str] :keyword properties: Properties of the vault. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2023_07_01.models.VaultProperties + :paramtype properties: ~azure.mgmt.keyvault.v2024_11_01.models.VaultProperties """ super().__init__(**kwargs) self.id = None @@ -3956,7 +3975,7 @@ class VaultAccessPolicyParameters(_serialization.Model): :ivar location: The resource type of the access policy. :vartype location: str :ivar properties: Properties of the access policy. Required. - :vartype properties: ~azure.mgmt.keyvault.v2023_07_01.models.VaultAccessPolicyProperties + :vartype properties: ~azure.mgmt.keyvault.v2024_11_01.models.VaultAccessPolicyProperties """ _validation = { @@ -3978,7 +3997,7 @@ class VaultAccessPolicyParameters(_serialization.Model): def __init__(self, *, properties: "_models.VaultAccessPolicyProperties", **kwargs: Any) -> None: """ :keyword properties: Properties of the access policy. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2023_07_01.models.VaultAccessPolicyProperties + :paramtype properties: ~azure.mgmt.keyvault.v2024_11_01.models.VaultAccessPolicyProperties """ super().__init__(**kwargs) self.id = None @@ -3995,7 +4014,7 @@ class VaultAccessPolicyProperties(_serialization.Model): :ivar access_policies: An array of 0 to 16 identities that have access to the key vault. All identities in the array must use the same tenant ID as the key vault's tenant ID. Required. - :vartype access_policies: list[~azure.mgmt.keyvault.v2023_07_01.models.AccessPolicyEntry] + :vartype access_policies: list[~azure.mgmt.keyvault.v2024_11_01.models.AccessPolicyEntry] """ _validation = { @@ -4010,7 +4029,7 @@ def __init__(self, *, access_policies: List["_models.AccessPolicyEntry"], **kwar """ :keyword access_policies: An array of 0 to 16 identities that have access to the key vault. All identities in the array must use the same tenant ID as the key vault's tenant ID. Required. - :paramtype access_policies: list[~azure.mgmt.keyvault.v2023_07_01.models.AccessPolicyEntry] + :paramtype access_policies: list[~azure.mgmt.keyvault.v2024_11_01.models.AccessPolicyEntry] """ super().__init__(**kwargs) self.access_policies = access_policies @@ -4061,7 +4080,7 @@ class VaultCreateOrUpdateParameters(_serialization.Model): :ivar tags: The tags that will be assigned to the key vault. :vartype tags: dict[str, str] :ivar properties: Properties of the vault. Required. - :vartype properties: ~azure.mgmt.keyvault.v2023_07_01.models.VaultProperties + :vartype properties: ~azure.mgmt.keyvault.v2024_11_01.models.VaultProperties """ _validation = { @@ -4090,7 +4109,7 @@ def __init__( :keyword tags: The tags that will be assigned to the key vault. :paramtype tags: dict[str, str] :keyword properties: Properties of the vault. Required. - :paramtype properties: ~azure.mgmt.keyvault.v2023_07_01.models.VaultProperties + :paramtype properties: ~azure.mgmt.keyvault.v2024_11_01.models.VaultProperties """ super().__init__(**kwargs) self.location = location @@ -4102,7 +4121,7 @@ class VaultListResult(_serialization.Model): """List of vaults. :ivar value: The list of vaults. - :vartype value: list[~azure.mgmt.keyvault.v2023_07_01.models.Vault] + :vartype value: list[~azure.mgmt.keyvault.v2024_11_01.models.Vault] :ivar next_link: The URL to get the next set of vaults. :vartype next_link: str """ @@ -4117,7 +4136,7 @@ def __init__( ) -> None: """ :keyword value: The list of vaults. - :paramtype value: list[~azure.mgmt.keyvault.v2023_07_01.models.Vault] + :paramtype value: list[~azure.mgmt.keyvault.v2024_11_01.models.Vault] :keyword next_link: The URL to get the next set of vaults. :paramtype next_link: str """ @@ -4132,7 +4151,7 @@ class VaultPatchParameters(_serialization.Model): :ivar tags: The tags that will be assigned to the key vault. :vartype tags: dict[str, str] :ivar properties: Properties of the vault. - :vartype properties: ~azure.mgmt.keyvault.v2023_07_01.models.VaultPatchProperties + :vartype properties: ~azure.mgmt.keyvault.v2024_11_01.models.VaultPatchProperties """ _attribute_map = { @@ -4151,24 +4170,24 @@ def __init__( :keyword tags: The tags that will be assigned to the key vault. :paramtype tags: dict[str, str] :keyword properties: Properties of the vault. - :paramtype properties: ~azure.mgmt.keyvault.v2023_07_01.models.VaultPatchProperties + :paramtype properties: ~azure.mgmt.keyvault.v2024_11_01.models.VaultPatchProperties """ super().__init__(**kwargs) self.tags = tags self.properties = properties -class VaultPatchProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes +class VaultPatchProperties(_serialization.Model): """Properties of the vault. :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating requests to the key vault. :vartype tenant_id: str :ivar sku: SKU details. - :vartype sku: ~azure.mgmt.keyvault.v2023_07_01.models.Sku + :vartype sku: ~azure.mgmt.keyvault.v2024_11_01.models.Sku :ivar access_policies: An array of 0 to 16 identities that have access to the key vault. All identities in the array must use the same tenant ID as the key vault's tenant ID. - :vartype access_policies: list[~azure.mgmt.keyvault.v2023_07_01.models.AccessPolicyEntry] + :vartype access_policies: list[~azure.mgmt.keyvault.v2024_11_01.models.AccessPolicyEntry] :ivar enabled_for_deployment: Property to specify whether Azure Virtual Machines are permitted to retrieve certificates stored as secrets from the key vault. :vartype enabled_for_deployment: bool @@ -4192,7 +4211,7 @@ class VaultPatchProperties(_serialization.Model): # pylint: disable=too-many-in :vartype soft_delete_retention_in_days: int :ivar create_mode: The vault's create mode to indicate whether the vault need to be recovered or not. Known values are: "recover" and "default". - :vartype create_mode: str or ~azure.mgmt.keyvault.v2023_07_01.models.CreateMode + :vartype create_mode: str or ~azure.mgmt.keyvault.v2024_11_01.models.CreateMode :ivar enable_purge_protection: Property specifying whether protection against purge is enabled for this vault. Setting this property to true activates protection against purge for this vault and its content - only the Key Vault service may initiate a hard, irrecoverable deletion. The @@ -4201,7 +4220,7 @@ class VaultPatchProperties(_serialization.Model): # pylint: disable=too-many-in :vartype enable_purge_protection: bool :ivar network_acls: A collection of rules governing the accessibility of the vault from specific network locations. - :vartype network_acls: ~azure.mgmt.keyvault.v2023_07_01.models.NetworkRuleSet + :vartype network_acls: ~azure.mgmt.keyvault.v2024_11_01.models.NetworkRuleSet :ivar public_network_access: Property to specify whether the vault will accept traffic from public internet. If set to 'disabled' all traffic except private endpoint traffic and that that originates from trusted services will be blocked. This will override the set firewall rules, @@ -4248,10 +4267,10 @@ def __init__( requests to the key vault. :paramtype tenant_id: str :keyword sku: SKU details. - :paramtype sku: ~azure.mgmt.keyvault.v2023_07_01.models.Sku + :paramtype sku: ~azure.mgmt.keyvault.v2024_11_01.models.Sku :keyword access_policies: An array of 0 to 16 identities that have access to the key vault. All identities in the array must use the same tenant ID as the key vault's tenant ID. - :paramtype access_policies: list[~azure.mgmt.keyvault.v2023_07_01.models.AccessPolicyEntry] + :paramtype access_policies: list[~azure.mgmt.keyvault.v2024_11_01.models.AccessPolicyEntry] :keyword enabled_for_deployment: Property to specify whether Azure Virtual Machines are permitted to retrieve certificates stored as secrets from the key vault. :paramtype enabled_for_deployment: bool @@ -4276,7 +4295,7 @@ def __init__( :paramtype soft_delete_retention_in_days: int :keyword create_mode: The vault's create mode to indicate whether the vault need to be recovered or not. Known values are: "recover" and "default". - :paramtype create_mode: str or ~azure.mgmt.keyvault.v2023_07_01.models.CreateMode + :paramtype create_mode: str or ~azure.mgmt.keyvault.v2024_11_01.models.CreateMode :keyword enable_purge_protection: Property specifying whether protection against purge is enabled for this vault. Setting this property to true activates protection against purge for this vault and its content - only the Key Vault service may initiate a hard, irrecoverable @@ -4285,7 +4304,7 @@ def __init__( :paramtype enable_purge_protection: bool :keyword network_acls: A collection of rules governing the accessibility of the vault from specific network locations. - :paramtype network_acls: ~azure.mgmt.keyvault.v2023_07_01.models.NetworkRuleSet + :paramtype network_acls: ~azure.mgmt.keyvault.v2024_11_01.models.NetworkRuleSet :keyword public_network_access: Property to specify whether the vault will accept traffic from public internet. If set to 'disabled' all traffic except private endpoint traffic and that that originates from trusted services will be blocked. This will override the set firewall rules, @@ -4308,7 +4327,7 @@ def __init__( self.public_network_access = public_network_access -class VaultProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes +class VaultProperties(_serialization.Model): """Properties of the vault. Variables are only populated by the server, and will be ignored when sending a request. @@ -4319,12 +4338,12 @@ class VaultProperties(_serialization.Model): # pylint: disable=too-many-instanc requests to the key vault. Required. :vartype tenant_id: str :ivar sku: SKU details. Required. - :vartype sku: ~azure.mgmt.keyvault.v2023_07_01.models.Sku + :vartype sku: ~azure.mgmt.keyvault.v2024_11_01.models.Sku :ivar access_policies: An array of 0 to 1024 identities that have access to the key vault. All identities in the array must use the same tenant ID as the key vault's tenant ID. When ``createMode`` is set to ``recover``\\ , access policies are not required. Otherwise, access policies are required. - :vartype access_policies: list[~azure.mgmt.keyvault.v2023_07_01.models.AccessPolicyEntry] + :vartype access_policies: list[~azure.mgmt.keyvault.v2024_11_01.models.AccessPolicyEntry] :ivar vault_uri: The URI of the vault for performing operations on keys and secrets. :vartype vault_uri: str :ivar hsm_pool_resource_id: The resource id of HSM Pool. @@ -4353,7 +4372,7 @@ class VaultProperties(_serialization.Model): # pylint: disable=too-many-instanc :vartype enable_rbac_authorization: bool :ivar create_mode: The vault's create mode to indicate whether the vault need to be recovered or not. Known values are: "recover" and "default". - :vartype create_mode: str or ~azure.mgmt.keyvault.v2023_07_01.models.CreateMode + :vartype create_mode: str or ~azure.mgmt.keyvault.v2024_11_01.models.CreateMode :ivar enable_purge_protection: Property specifying whether protection against purge is enabled for this vault. Setting this property to true activates protection against purge for this vault and its content - only the Key Vault service may initiate a hard, irrecoverable deletion. The @@ -4362,15 +4381,15 @@ class VaultProperties(_serialization.Model): # pylint: disable=too-many-instanc :vartype enable_purge_protection: bool :ivar network_acls: Rules governing the accessibility of the key vault from specific network locations. - :vartype network_acls: ~azure.mgmt.keyvault.v2023_07_01.models.NetworkRuleSet + :vartype network_acls: ~azure.mgmt.keyvault.v2024_11_01.models.NetworkRuleSet :ivar provisioning_state: Provisioning state of the vault. Known values are: "Succeeded" and "RegisteringDns". :vartype provisioning_state: str or - ~azure.mgmt.keyvault.v2023_07_01.models.VaultProvisioningState + ~azure.mgmt.keyvault.v2024_11_01.models.VaultProvisioningState :ivar private_endpoint_connections: List of private endpoint connections associated with the key vault. :vartype private_endpoint_connections: - list[~azure.mgmt.keyvault.v2023_07_01.models.PrivateEndpointConnectionItem] + list[~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnectionItem] :ivar public_network_access: Property to specify whether the vault will accept traffic from public internet. If set to 'disabled' all traffic except private endpoint traffic and that that originates from trusted services will be blocked. This will override the set firewall rules, @@ -4415,9 +4434,9 @@ def __init__( sku: "_models.Sku", access_policies: Optional[List["_models.AccessPolicyEntry"]] = None, vault_uri: Optional[str] = None, - enabled_for_deployment: Optional[bool] = None, - enabled_for_disk_encryption: Optional[bool] = None, - enabled_for_template_deployment: Optional[bool] = None, + enabled_for_deployment: bool = False, + enabled_for_disk_encryption: bool = False, + enabled_for_template_deployment: bool = False, enable_soft_delete: bool = True, soft_delete_retention_in_days: int = 90, enable_rbac_authorization: bool = False, @@ -4433,12 +4452,12 @@ def __init__( requests to the key vault. Required. :paramtype tenant_id: str :keyword sku: SKU details. Required. - :paramtype sku: ~azure.mgmt.keyvault.v2023_07_01.models.Sku + :paramtype sku: ~azure.mgmt.keyvault.v2024_11_01.models.Sku :keyword access_policies: An array of 0 to 1024 identities that have access to the key vault. All identities in the array must use the same tenant ID as the key vault's tenant ID. When ``createMode`` is set to ``recover``\\ , access policies are not required. Otherwise, access policies are required. - :paramtype access_policies: list[~azure.mgmt.keyvault.v2023_07_01.models.AccessPolicyEntry] + :paramtype access_policies: list[~azure.mgmt.keyvault.v2024_11_01.models.AccessPolicyEntry] :keyword vault_uri: The URI of the vault for performing operations on keys and secrets. :paramtype vault_uri: str :keyword enabled_for_deployment: Property to specify whether Azure Virtual Machines are @@ -4466,7 +4485,7 @@ def __init__( :paramtype enable_rbac_authorization: bool :keyword create_mode: The vault's create mode to indicate whether the vault need to be recovered or not. Known values are: "recover" and "default". - :paramtype create_mode: str or ~azure.mgmt.keyvault.v2023_07_01.models.CreateMode + :paramtype create_mode: str or ~azure.mgmt.keyvault.v2024_11_01.models.CreateMode :keyword enable_purge_protection: Property specifying whether protection against purge is enabled for this vault. Setting this property to true activates protection against purge for this vault and its content - only the Key Vault service may initiate a hard, irrecoverable @@ -4475,11 +4494,11 @@ def __init__( :paramtype enable_purge_protection: bool :keyword network_acls: Rules governing the accessibility of the key vault from specific network locations. - :paramtype network_acls: ~azure.mgmt.keyvault.v2023_07_01.models.NetworkRuleSet + :paramtype network_acls: ~azure.mgmt.keyvault.v2024_11_01.models.NetworkRuleSet :keyword provisioning_state: Provisioning state of the vault. Known values are: "Succeeded" and "RegisteringDns". :paramtype provisioning_state: str or - ~azure.mgmt.keyvault.v2023_07_01.models.VaultProvisioningState + ~azure.mgmt.keyvault.v2024_11_01.models.VaultProvisioningState :keyword public_network_access: Property to specify whether the vault will accept traffic from public internet. If set to 'disabled' all traffic except private endpoint traffic and that that originates from trusted services will be blocked. This will override the set firewall rules, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/models/_patch.py similarity index 100% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/_patch.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/models/_patch.py diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/__init__.py similarity index 59% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/__init__.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/__init__.py index 5f02a0a74b92..2c20c64a2fa5 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/__init__.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/__init__.py @@ -5,21 +5,27 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +# pylint: disable=wrong-import-position -from ._keys_operations import KeysOperations -from ._managed_hsm_keys_operations import ManagedHsmKeysOperations -from ._vaults_operations import VaultsOperations -from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations -from ._private_link_resources_operations import PrivateLinkResourcesOperations -from ._managed_hsms_operations import ManagedHsmsOperations -from ._mhsm_private_endpoint_connections_operations import MHSMPrivateEndpointConnectionsOperations -from ._mhsm_private_link_resources_operations import MHSMPrivateLinkResourcesOperations -from ._mhsm_regions_operations import MHSMRegionsOperations -from ._operations import Operations -from ._secrets_operations import SecretsOperations +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._keys_operations import KeysOperations # type: ignore +from ._managed_hsm_keys_operations import ManagedHsmKeysOperations # type: ignore +from ._vaults_operations import VaultsOperations # type: ignore +from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations # type: ignore +from ._private_link_resources_operations import PrivateLinkResourcesOperations # type: ignore +from ._managed_hsms_operations import ManagedHsmsOperations # type: ignore +from ._mhsm_private_endpoint_connections_operations import MHSMPrivateEndpointConnectionsOperations # type: ignore +from ._mhsm_private_link_resources_operations import MHSMPrivateLinkResourcesOperations # type: ignore +from ._mhsm_regions_operations import MHSMRegionsOperations # type: ignore +from ._operations import Operations # type: ignore +from ._secrets_operations import SecretsOperations # type: ignore from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import +from ._patch import * from ._patch import patch_sdk as _patch_sdk __all__ = [ @@ -35,5 +41,5 @@ "Operations", "SecretsOperations", ] -__all__.extend([p for p in _patch_all if p not in __all__]) +__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_keys_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_keys_operations.py similarity index 95% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_keys_operations.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_keys_operations.py index 9074753c578e..b869eeb7b34c 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_keys_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_keys_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +7,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, Callable, Dict, IO, Iterable, Optional, Type, TypeVar, Union, overload +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload import urllib.parse from azure.core.exceptions import ( @@ -32,7 +31,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -46,7 +45,7 @@ def build_create_if_not_exist_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") @@ -81,7 +80,7 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -111,7 +110,7 @@ def build_list_request(resource_group_name: str, vault_name: str, subscription_i _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -142,7 +141,7 @@ def build_get_version_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -175,7 +174,7 @@ def build_list_versions_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -207,7 +206,7 @@ class KeysOperations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2022_07_01.KeyVaultManagementClient`'s + :class:`~azure.mgmt.keyvault.v2024_11_01.KeyVaultManagementClient`'s :attr:`keys` attribute. """ @@ -246,12 +245,12 @@ def create_if_not_exist( personally identifiable or sensitive information. Required. :type key_name: str :param parameters: The parameters used to create the specified key. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.KeyCreateParameters + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.KeyCreateParameters :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Key + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Key :raises ~azure.core.exceptions.HttpResponseError: """ @@ -285,7 +284,7 @@ def create_if_not_exist( Default value is "application/json". :paramtype content_type: str :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Key + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Key :raises ~azure.core.exceptions.HttpResponseError: """ @@ -313,12 +312,12 @@ def create_if_not_exist( :type key_name: str :param parameters: The parameters used to create the specified key. Is either a KeyCreateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.KeyCreateParameters or IO[bytes] + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.KeyCreateParameters or IO[bytes] :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Key + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Key :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -329,7 +328,7 @@ def create_if_not_exist( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.Key] = kwargs.pop("cls", None) @@ -385,10 +384,10 @@ def get(self, resource_group_name: str, vault_name: str, key_name: str, **kwargs :param key_name: The name of the key to be retrieved. Required. :type key_name: str :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Key + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Key :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -399,7 +398,7 @@ def get(self, resource_group_name: str, vault_name: str, key_name: str, **kwargs _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.Key] = kwargs.pop("cls", None) _request = build_get_request( @@ -441,16 +440,16 @@ def list(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> Iter :param vault_name: The name of the vault which contains the keys to be retrieved. Required. :type vault_name: str :return: An iterator like instance of either Key or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.Key] + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.Key] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -529,10 +528,10 @@ def get_version( :param key_version: The version of the key to be retrieved. Required. :type key_version: str :return: Key or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Key + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Key :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -543,7 +542,7 @@ def get_version( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.Key] = kwargs.pop("cls", None) _request = build_get_version_request( @@ -591,16 +590,16 @@ def list_versions( :param key_name: The name of the key versions to be retrieved. Required. :type key_name: str :return: An iterator like instance of either Key or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.Key] + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.Key] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.KeyListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_managed_hsm_keys_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_managed_hsm_keys_operations.py similarity index 95% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_managed_hsm_keys_operations.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_managed_hsm_keys_operations.py index a1dbe935cb26..8afcb811f3dc 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_managed_hsm_keys_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_managed_hsm_keys_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +7,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, Callable, Dict, IO, Iterable, Optional, Type, TypeVar, Union, overload +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload import urllib.parse from azure.core.exceptions import ( @@ -32,7 +31,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -46,7 +45,7 @@ def build_create_if_not_exist_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") @@ -85,7 +84,7 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -119,7 +118,7 @@ def build_list_request(resource_group_name: str, name: str, subscription_id: str _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -154,7 +153,7 @@ def build_get_version_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -191,7 +190,7 @@ def build_list_versions_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -227,7 +226,7 @@ class ManagedHsmKeysOperations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2023_07_01.KeyVaultManagementClient`'s + :class:`~azure.mgmt.keyvault.v2024_11_01.KeyVaultManagementClient`'s :attr:`managed_hsm_keys` attribute. """ @@ -266,12 +265,12 @@ def create_if_not_exist( personally identifiable or sensitive information. Required. :type key_name: str :param parameters: The parameters used to create the specified key. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKeyCreateParameters + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKeyCreateParameters :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: ManagedHsmKey or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKey + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKey :raises ~azure.core.exceptions.HttpResponseError: """ @@ -305,7 +304,7 @@ def create_if_not_exist( Default value is "application/json". :paramtype content_type: str :return: ManagedHsmKey or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKey + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKey :raises ~azure.core.exceptions.HttpResponseError: """ @@ -333,13 +332,13 @@ def create_if_not_exist( :type key_name: str :param parameters: The parameters used to create the specified key. Is either a ManagedHsmKeyCreateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKeyCreateParameters or + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKeyCreateParameters or IO[bytes] :return: ManagedHsmKey or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKey + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKey :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -350,7 +349,7 @@ def create_if_not_exist( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.ManagedHsmKey] = kwargs.pop("cls", None) @@ -408,10 +407,10 @@ def get(self, resource_group_name: str, name: str, key_name: str, **kwargs: Any) personally identifiable or sensitive information. Required. :type key_name: str :return: ManagedHsmKey or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKey + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKey :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -422,7 +421,7 @@ def get(self, resource_group_name: str, name: str, key_name: str, **kwargs: Any) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.ManagedHsmKey] = kwargs.pop("cls", None) _request = build_get_request( @@ -464,16 +463,16 @@ def list(self, resource_group_name: str, name: str, **kwargs: Any) -> Iterable[" :param name: The name of the Managed HSM Pool within the specified resource group. Required. :type name: str :return: An iterator like instance of either ManagedHsmKey or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKey] + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKey] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.ManagedHsmKeyListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -553,10 +552,10 @@ def get_version( :param key_version: The version of the key to be retrieved. Required. :type key_version: str :return: ManagedHsmKey or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKey + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKey :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -567,7 +566,7 @@ def get_version( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.ManagedHsmKey] = kwargs.pop("cls", None) _request = build_get_version_request( @@ -616,16 +615,16 @@ def list_versions( personally identifiable or sensitive information. Required. :type key_name: str :return: An iterator like instance of either ManagedHsmKey or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsmKey] + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsmKey] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.ManagedHsmKeyListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_managed_hsms_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_managed_hsms_operations.py similarity index 93% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_managed_hsms_operations.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_managed_hsms_operations.py index e68cce8862df..0c684d85eec0 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_managed_hsms_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_managed_hsms_operations.py @@ -1,4 +1,4 @@ -# pylint: disable=too-many-lines,too-many-statements +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +8,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, Type, TypeVar, Union, cast, overload +from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, TypeVar, Union, cast, overload import urllib.parse from azure.core.exceptions import ( @@ -17,6 +17,8 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.paging import ItemPaged @@ -34,7 +36,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -48,7 +50,7 @@ def build_create_or_update_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") @@ -80,7 +82,7 @@ def build_update_request(resource_group_name: str, name: str, subscription_id: s _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") @@ -112,7 +114,7 @@ def build_delete_request(resource_group_name: str, name: str, subscription_id: s _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -141,7 +143,7 @@ def build_get_request(resource_group_name: str, name: str, subscription_id: str, _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -172,7 +174,7 @@ def build_list_by_resource_group_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -204,7 +206,7 @@ def build_list_by_subscription_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -230,7 +232,7 @@ def build_list_deleted_request(subscription_id: str, **kwargs: Any) -> HttpReque _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -254,7 +256,7 @@ def build_get_deleted_request(name: str, location: str, subscription_id: str, ** _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -283,7 +285,7 @@ def build_purge_deleted_request(name: str, location: str, subscription_id: str, _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -314,7 +316,7 @@ def build_check_mhsm_name_availability_request( # pylint: disable=name-too-long _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") @@ -345,7 +347,7 @@ class ManagedHsmsOperations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2023_07_01.KeyVaultManagementClient`'s + :class:`~azure.mgmt.keyvault.v2024_11_01.KeyVaultManagementClient`'s :attr:`managed_hsms` attribute. """ @@ -362,7 +364,7 @@ def __init__(self, *args, **kwargs): def _create_or_update_initial( self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -373,7 +375,7 @@ def _create_or_update_initial( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) @@ -398,6 +400,7 @@ def _create_or_update_initial( ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -406,19 +409,19 @@ def _create_or_update_initial( response = pipeline_response.http_response if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - if response.status_code == 202: response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -443,12 +446,12 @@ def begin_create_or_update( :param name: Name of the managed HSM Pool. Required. :type name: str :param parameters: Parameters to create or update the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm] + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm] :raises ~azure.core.exceptions.HttpResponseError: """ @@ -475,7 +478,7 @@ def begin_create_or_update( Default value is "application/json". :paramtype content_type: str :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm] + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm] :raises ~azure.core.exceptions.HttpResponseError: """ @@ -492,15 +495,15 @@ def begin_create_or_update( :type name: str :param parameters: Parameters to create or update the managed HSM Pool. Is either a ManagedHsm type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm or IO[bytes] + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm or IO[bytes] :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm] + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) @@ -547,7 +550,7 @@ def get_long_running_output(pipeline_response): def _update_initial( self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO[bytes]], **kwargs: Any ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -558,7 +561,7 @@ def _update_initial( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) @@ -583,6 +586,7 @@ def _update_initial( ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -591,19 +595,19 @@ def _update_initial( response = pipeline_response.http_response if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - if response.status_code == 202: response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -628,12 +632,12 @@ def begin_update( :param name: Name of the managed HSM Pool. Required. :type name: str :param parameters: Parameters to patch the managed HSM Pool. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm] + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm] :raises ~azure.core.exceptions.HttpResponseError: """ @@ -660,7 +664,7 @@ def begin_update( Default value is "application/json". :paramtype content_type: str :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm] + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm] :raises ~azure.core.exceptions.HttpResponseError: """ @@ -677,15 +681,15 @@ def begin_update( :type name: str :param parameters: Parameters to patch the managed HSM Pool. Is either a ManagedHsm type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm or IO[bytes] + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm or IO[bytes] :return: An instance of LROPoller that returns either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm] + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.ManagedHsm] = kwargs.pop("cls", None) polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) @@ -730,7 +734,7 @@ def get_long_running_output(pipeline_response): ) def _delete_initial(self, resource_group_name: str, name: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -741,7 +745,7 @@ def _delete_initial(self, resource_group_name: str, name: str, **kwargs: Any) -> _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) _request = build_delete_request( @@ -754,6 +758,7 @@ def _delete_initial(self, resource_group_name: str, name: str, **kwargs: Any) -> ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -762,22 +767,19 @@ def _delete_initial(self, resource_group_name: str, name: str, **kwargs: Any) -> response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: - response.read() # Load the body in memory and close the socket + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - if response.status_code == 202: response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -800,7 +802,7 @@ def begin_delete(self, resource_group_name: str, name: str, **kwargs: Any) -> LR _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[None] = kwargs.pop("cls", None) polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) @@ -847,10 +849,10 @@ def get(self, resource_group_name: str, name: str, **kwargs: Any) -> Optional[_m :param name: The name of the managed HSM Pool. Required. :type name: str :return: ManagedHsm or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm or None + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm or None :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -861,7 +863,7 @@ def get(self, resource_group_name: str, name: str, **kwargs: Any) -> Optional[_m _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[Optional[_models.ManagedHsm]] = kwargs.pop("cls", None) _request = build_get_request( @@ -908,16 +910,16 @@ def list_by_resource_group( :param top: Maximum number of results to return. Default value is None. :type top: int :return: An iterator like instance of either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm] + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -988,16 +990,16 @@ def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> Iter :param top: Maximum number of results to return. Default value is None. :type top: int :return: An iterator like instance of either ManagedHsm or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.ManagedHsm] + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.ManagedHsm] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.ManagedHsmListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1065,16 +1067,16 @@ def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedManagedHsm"]: subscription. :return: An iterator like instance of either DeletedManagedHsm or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.DeletedManagedHsm] + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.DeletedManagedHsm] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.DeletedManagedHsmListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1144,10 +1146,10 @@ def get_deleted(self, name: str, location: str, **kwargs: Any) -> _models.Delete :param location: The location of the deleted managed HSM. Required. :type location: str :return: DeletedManagedHsm or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.DeletedManagedHsm + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.DeletedManagedHsm :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1158,7 +1160,7 @@ def get_deleted(self, name: str, location: str, **kwargs: Any) -> _models.Delete _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.DeletedManagedHsm] = kwargs.pop("cls", None) _request = build_get_deleted_request( @@ -1191,7 +1193,7 @@ def get_deleted(self, name: str, location: str, **kwargs: Any) -> _models.Delete return deserialized # type: ignore def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1202,7 +1204,7 @@ def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) -> Ite _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) _request = build_purge_deleted_request( @@ -1215,6 +1217,7 @@ def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) -> Ite ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -1223,7 +1226,10 @@ def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) -> Ite response = pipeline_response.http_response if response.status_code not in [202]: - response.read() # Load the body in memory and close the socket + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) @@ -1231,7 +1237,7 @@ def _purge_deleted_initial(self, name: str, location: str, **kwargs: Any) -> Ite response_headers = {} response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -1253,7 +1259,7 @@ def begin_purge_deleted(self, name: str, location: str, **kwargs: Any) -> LROPol _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[None] = kwargs.pop("cls", None) polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) @@ -1301,12 +1307,12 @@ def check_mhsm_name_availability( """Checks that the managed hsm name is valid and is not already in use. :param mhsm_name: The name of the managed hsm. Required. - :type mhsm_name: ~azure.mgmt.keyvault.v2023_07_01.models.CheckMhsmNameAvailabilityParameters + :type mhsm_name: ~azure.mgmt.keyvault.v2024_11_01.models.CheckMhsmNameAvailabilityParameters :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: CheckMhsmNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.CheckMhsmNameAvailabilityResult + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.CheckMhsmNameAvailabilityResult :raises ~azure.core.exceptions.HttpResponseError: """ @@ -1322,7 +1328,7 @@ def check_mhsm_name_availability( Default value is "application/json". :paramtype content_type: str :return: CheckMhsmNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.CheckMhsmNameAvailabilityResult + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.CheckMhsmNameAvailabilityResult :raises ~azure.core.exceptions.HttpResponseError: """ @@ -1334,13 +1340,13 @@ def check_mhsm_name_availability( :param mhsm_name: The name of the managed hsm. Is either a CheckMhsmNameAvailabilityParameters type or a IO[bytes] type. Required. - :type mhsm_name: ~azure.mgmt.keyvault.v2023_07_01.models.CheckMhsmNameAvailabilityParameters or + :type mhsm_name: ~azure.mgmt.keyvault.v2024_11_01.models.CheckMhsmNameAvailabilityParameters or IO[bytes] :return: CheckMhsmNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.CheckMhsmNameAvailabilityResult + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.CheckMhsmNameAvailabilityResult :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1351,7 +1357,7 @@ def check_mhsm_name_availability( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.CheckMhsmNameAvailabilityResult] = kwargs.pop("cls", None) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_mhsm_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_mhsm_private_endpoint_connections_operations.py similarity index 93% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_mhsm_private_endpoint_connections_operations.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_mhsm_private_endpoint_connections_operations.py index 1a9d3215ed28..b21e9c50ecdc 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_mhsm_private_endpoint_connections_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_mhsm_private_endpoint_connections_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +7,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, Type, TypeVar, Union, cast, overload +from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, TypeVar, Union, cast, overload import urllib.parse from azure.core.exceptions import ( @@ -17,6 +16,8 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.paging import ItemPaged @@ -34,7 +35,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -48,7 +49,7 @@ def build_list_by_resource_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -79,7 +80,7 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -113,7 +114,7 @@ def build_put_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") @@ -150,7 +151,7 @@ def build_delete_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -184,7 +185,7 @@ class MHSMPrivateEndpointConnectionsOperations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2023_07_01.KeyVaultManagementClient`'s + :class:`~azure.mgmt.keyvault.v2024_11_01.KeyVaultManagementClient`'s :attr:`mhsm_private_endpoint_connections` attribute. """ @@ -213,16 +214,16 @@ def list_by_resource( :return: An iterator like instance of either MHSMPrivateEndpointConnection or the result of cls(response) :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpointConnection] + ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpointConnection] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -300,10 +301,10 @@ def get( with the managed hsm pool. Required. :type private_endpoint_connection_name: str :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpointConnection + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpointConnection :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -314,7 +315,7 @@ def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) _request = build_get_request( @@ -369,12 +370,12 @@ def put( with the managed hsm pool. Required. :type private_endpoint_connection_name: str :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpointConnection + :type properties: ~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpointConnection :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpointConnection + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpointConnection :raises ~azure.core.exceptions.HttpResponseError: """ @@ -405,7 +406,7 @@ def put( Default value is "application/json". :paramtype content_type: str :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpointConnection + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpointConnection :raises ~azure.core.exceptions.HttpResponseError: """ @@ -430,13 +431,13 @@ def put( :type private_endpoint_connection_name: str :param properties: The intended state of private endpoint connection. Is either a MHSMPrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpointConnection or + :type properties: ~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpointConnection or IO[bytes] :return: MHSMPrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpointConnection + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpointConnection :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -447,7 +448,7 @@ def put( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) @@ -500,7 +501,7 @@ def put( def _delete_initial( self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -511,7 +512,7 @@ def _delete_initial( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) _request = build_delete_request( @@ -525,6 +526,7 @@ def _delete_initial( ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -533,21 +535,18 @@ def _delete_initial( response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: - response.read() # Load the body in memory and close the socket + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - if response.status_code == 202: response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -571,13 +570,13 @@ def begin_delete( :return: An instance of LROPoller that returns either MHSMPrivateEndpointConnection or the result of cls(response) :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateEndpointConnection] + ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateEndpointConnection] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.MHSMPrivateEndpointConnection] = kwargs.pop("cls", None) polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_mhsm_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_mhsm_private_link_resources_operations.py similarity index 92% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_mhsm_private_link_resources_operations.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_mhsm_private_link_resources_operations.py index 9d1a1af1668f..0f642ce90089 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_mhsm_private_link_resources_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_mhsm_private_link_resources_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,7 +6,7 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar +from typing import Any, Callable, Dict, Optional, TypeVar from azure.core.exceptions import ( ClientAuthenticationError, @@ -29,7 +28,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -43,7 +42,7 @@ def build_list_by_mhsm_resource_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -74,7 +73,7 @@ class MHSMPrivateLinkResourcesOperations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2023_07_01.KeyVaultManagementClient`'s + :class:`~azure.mgmt.keyvault.v2024_11_01.KeyVaultManagementClient`'s :attr:`mhsm_private_link_resources` attribute. """ @@ -100,10 +99,10 @@ def list_by_mhsm_resource( :param name: Name of the managed HSM Pool. Required. :type name: str :return: MHSMPrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.MHSMPrivateLinkResourceListResult + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.MHSMPrivateLinkResourceListResult :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -114,7 +113,7 @@ def list_by_mhsm_resource( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.MHSMPrivateLinkResourceListResult] = kwargs.pop("cls", None) _request = build_list_by_mhsm_resource_request( diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_mhsm_regions_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_mhsm_regions_operations.py similarity index 93% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_mhsm_regions_operations.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_mhsm_regions_operations.py index fdd53047bf43..ae8c70f657d4 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_mhsm_regions_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_mhsm_regions_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,7 +6,7 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import sys -from typing import Any, Callable, Dict, Iterable, Optional, Type, TypeVar +from typing import Any, Callable, Dict, Iterable, Optional, TypeVar import urllib.parse from azure.core.exceptions import ( @@ -31,7 +30,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -45,7 +44,7 @@ def build_list_by_resource_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -76,7 +75,7 @@ class MHSMRegionsOperations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2023_07_01.KeyVaultManagementClient`'s + :class:`~azure.mgmt.keyvault.v2024_11_01.KeyVaultManagementClient`'s :attr:`mhsm_regions` attribute. """ @@ -104,16 +103,16 @@ def list_by_resource( :return: An iterator like instance of either MHSMGeoReplicatedRegion or the result of cls(response) :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.MHSMGeoReplicatedRegion] + ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.MHSMGeoReplicatedRegion] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.MHSMRegionsListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_operations.py similarity index 93% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_operations.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_operations.py index ff133038b63d..1057f5f1dd81 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,7 +6,7 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import sys -from typing import Any, Callable, Dict, Iterable, Optional, Type, TypeVar +from typing import Any, Callable, Dict, Iterable, Optional, TypeVar import urllib.parse from azure.core.exceptions import ( @@ -31,7 +30,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -43,7 +42,7 @@ def build_list_request(**kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -64,7 +63,7 @@ class Operations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_10_01.KeyVaultManagementClient`'s + :class:`~azure.mgmt.keyvault.v2024_11_01.KeyVaultManagementClient`'s :attr:`operations` attribute. """ @@ -83,16 +82,16 @@ def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: """Lists all of the available Key Vault Rest API operations. :return: An iterator like instance of either Operation or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.Operation] + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.Operation] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_patch.py similarity index 100% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/_patch.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_patch.py diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_private_endpoint_connections_operations.py similarity index 93% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_private_endpoint_connections_operations.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_private_endpoint_connections_operations.py index 954e368c4943..5799cad566ab 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/operations/_private_endpoint_connections_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_private_endpoint_connections_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +7,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, Type, TypeVar, Union, cast, overload +from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, TypeVar, Union, cast, overload import urllib.parse from azure.core.exceptions import ( @@ -17,6 +16,8 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.paging import ItemPaged @@ -34,7 +35,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -52,7 +53,7 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -90,7 +91,7 @@ def build_put_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") @@ -131,7 +132,7 @@ def build_delete_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -165,7 +166,7 @@ def build_list_by_resource_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -196,7 +197,7 @@ class PrivateEndpointConnectionsOperations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2022_07_01.KeyVaultManagementClient`'s + :class:`~azure.mgmt.keyvault.v2024_11_01.KeyVaultManagementClient`'s :attr:`private_endpoint_connections` attribute. """ @@ -224,10 +225,10 @@ def get( with the key vault. Required. :type private_endpoint_connection_name: str :return: PrivateEndpointConnection or None or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection or None + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnection or None :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -238,7 +239,7 @@ def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[Optional[_models.PrivateEndpointConnection]] = kwargs.pop("cls", None) _request = build_get_request( @@ -293,12 +294,12 @@ def put( with the key vault. Required. :type private_endpoint_connection_name: str :param properties: The intended state of private endpoint connection. Required. - :type properties: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection + :type properties: ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnection :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnection :raises ~azure.core.exceptions.HttpResponseError: """ @@ -328,7 +329,7 @@ def put( Default value is "application/json". :paramtype content_type: str :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnection :raises ~azure.core.exceptions.HttpResponseError: """ @@ -352,13 +353,13 @@ def put( :type private_endpoint_connection_name: str :param properties: The intended state of private endpoint connection. Is either a PrivateEndpointConnection type or a IO[bytes] type. Required. - :type properties: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection or + :type properties: ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnection or IO[bytes] :return: PrivateEndpointConnection or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnection :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -369,7 +370,7 @@ def put( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) @@ -422,7 +423,7 @@ def put( def _delete_initial( self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -433,7 +434,7 @@ def _delete_initial( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) _request = build_delete_request( @@ -447,6 +448,7 @@ def _delete_initial( ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -455,22 +457,19 @@ def _delete_initial( response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: - response.read() # Load the body in memory and close the socket + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - if response.status_code == 202: response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 204: - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -493,13 +492,13 @@ def begin_delete( :return: An instance of LROPoller that returns either PrivateEndpointConnection or the result of cls(response) :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection] + ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnection] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.PrivateEndpointConnection] = kwargs.pop("cls", None) polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) @@ -555,16 +554,16 @@ def list_by_resource( :return: An iterator like instance of either PrivateEndpointConnection or the result of cls(response) :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection] + ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.PrivateEndpointConnection] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2022-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.PrivateEndpointConnectionListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_private_link_resources_operations.py similarity index 92% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_private_link_resources_operations.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_private_link_resources_operations.py index c8e217ffdaa8..8e2a74c45f85 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_private_link_resources_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_private_link_resources_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,7 +6,7 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import sys -from typing import Any, Callable, Dict, Optional, Type, TypeVar +from typing import Any, Callable, Dict, Optional, TypeVar from azure.core.exceptions import ( ClientAuthenticationError, @@ -29,7 +28,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -43,7 +42,7 @@ def build_list_by_vault_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -74,7 +73,7 @@ class PrivateLinkResourcesOperations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_10_01.KeyVaultManagementClient`'s + :class:`~azure.mgmt.keyvault.v2024_11_01.KeyVaultManagementClient`'s :attr:`private_link_resources` attribute. """ @@ -99,10 +98,10 @@ def list_by_vault( :param vault_name: The name of the key vault. Required. :type vault_name: str :return: PrivateLinkResourceListResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateLinkResourceListResult + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.PrivateLinkResourceListResult :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -113,7 +112,7 @@ def list_by_vault( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.PrivateLinkResourceListResult] = kwargs.pop("cls", None) _request = build_list_by_vault_request( diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_secrets_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_secrets_operations.py similarity index 92% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_secrets_operations.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_secrets_operations.py index 2bf4784fb4ec..81989897a90d 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2023_07_01/operations/_secrets_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_secrets_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines,too-many-statements # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +7,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, Callable, Dict, IO, Iterable, Optional, Type, TypeVar, Union, overload +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload import urllib.parse from azure.core.exceptions import ( @@ -32,7 +31,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -46,7 +45,7 @@ def build_create_or_update_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") @@ -81,7 +80,7 @@ def build_update_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") @@ -116,7 +115,7 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -148,7 +147,7 @@ def build_list_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -181,7 +180,7 @@ class SecretsOperations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2023_07_01.KeyVaultManagementClient`'s + :class:`~azure.mgmt.keyvault.v2024_11_01.KeyVaultManagementClient`'s :attr:`secrets` attribute. """ @@ -220,12 +219,12 @@ def create_or_update( or sensitive information. Required. :type secret_name: str :param parameters: Parameters to create or update the secret. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.SecretCreateOrUpdateParameters + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.SecretCreateOrUpdateParameters :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Secret + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Secret :raises ~azure.core.exceptions.HttpResponseError: """ @@ -259,7 +258,7 @@ def create_or_update( Default value is "application/json". :paramtype content_type: str :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Secret + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Secret :raises ~azure.core.exceptions.HttpResponseError: """ @@ -287,13 +286,13 @@ def create_or_update( :type secret_name: str :param parameters: Parameters to create or update the secret. Is either a SecretCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.SecretCreateOrUpdateParameters or + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.SecretCreateOrUpdateParameters or IO[bytes] :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Secret + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Secret :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -304,7 +303,7 @@ def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.Secret] = kwargs.pop("cls", None) @@ -341,11 +340,7 @@ def create_or_update( map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) + deserialized = self._deserialize("Secret", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -375,12 +370,12 @@ def update( :param secret_name: Name of the secret. Required. :type secret_name: str :param parameters: Parameters to patch the secret. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.SecretPatchParameters + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.SecretPatchParameters :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Secret + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Secret :raises ~azure.core.exceptions.HttpResponseError: """ @@ -412,7 +407,7 @@ def update( Default value is "application/json". :paramtype content_type: str :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Secret + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Secret :raises ~azure.core.exceptions.HttpResponseError: """ @@ -438,12 +433,12 @@ def update( :type secret_name: str :param parameters: Parameters to patch the secret. Is either a SecretPatchParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2023_07_01.models.SecretPatchParameters or IO[bytes] + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.SecretPatchParameters or IO[bytes] :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Secret + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Secret :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -454,7 +449,7 @@ def update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.Secret] = kwargs.pop("cls", None) @@ -491,11 +486,7 @@ def update( map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("Secret", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Secret", pipeline_response.http_response) + deserialized = self._deserialize("Secret", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -515,10 +506,10 @@ def get(self, resource_group_name: str, vault_name: str, secret_name: str, **kwa :param secret_name: The name of the secret. Required. :type secret_name: str :return: Secret or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2023_07_01.models.Secret + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Secret :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -529,7 +520,7 @@ def get(self, resource_group_name: str, vault_name: str, secret_name: str, **kwa _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.Secret] = kwargs.pop("cls", None) _request = build_get_request( @@ -577,16 +568,16 @@ def list( :param top: Maximum number of results to return. Default value is None. :type top: int :return: An iterator like instance of either Secret or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2023_07_01.models.Secret] + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.Secret] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2023-07-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.SecretListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_vaults_operations.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_vaults_operations.py similarity index 92% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_vaults_operations.py rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_vaults_operations.py index 85e44172334e..c21e034dbee9 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/operations/_vaults_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/operations/_vaults_operations.py @@ -1,4 +1,4 @@ -# pylint: disable=too-many-lines,too-many-statements +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -8,7 +8,7 @@ # -------------------------------------------------------------------------- from io import IOBase import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, Literal, Optional, Type, TypeVar, Union, cast, overload +from typing import Any, Callable, Dict, IO, Iterable, Iterator, Literal, Optional, TypeVar, Union, cast, overload import urllib.parse from azure.core.exceptions import ( @@ -17,6 +17,8 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.paging import ItemPaged @@ -34,7 +36,7 @@ if sys.version_info >= (3, 9): from collections.abc import MutableMapping else: - from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -48,7 +50,7 @@ def build_create_or_update_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") @@ -80,7 +82,7 @@ def build_update_request(resource_group_name: str, vault_name: str, subscription _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") @@ -112,7 +114,7 @@ def build_delete_request(resource_group_name: str, vault_name: str, subscription _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -141,7 +143,7 @@ def build_get_request(resource_group_name: str, vault_name: str, subscription_id _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -176,7 +178,7 @@ def build_update_access_policy_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") @@ -211,7 +213,7 @@ def build_list_by_resource_group_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -243,7 +245,7 @@ def build_list_by_subscription_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -269,7 +271,7 @@ def build_list_deleted_request(subscription_id: str, **kwargs: Any) -> HttpReque _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -293,7 +295,7 @@ def build_get_deleted_request(vault_name: str, location: str, subscription_id: s _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -322,7 +324,7 @@ def build_purge_deleted_request(vault_name: str, location: str, subscription_id: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -381,7 +383,7 @@ def build_check_name_availability_request(subscription_id: str, **kwargs: Any) - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") @@ -412,7 +414,7 @@ class VaultsOperations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.keyvault.v2021_10_01.KeyVaultManagementClient`'s + :class:`~azure.mgmt.keyvault.v2024_11_01.KeyVaultManagementClient`'s :attr:`vaults` attribute. """ @@ -433,7 +435,7 @@ def _create_or_update_initial( parameters: Union[_models.VaultCreateOrUpdateParameters, IO[bytes]], **kwargs: Any ) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -444,7 +446,7 @@ def _create_or_update_initial( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) @@ -469,6 +471,7 @@ def _create_or_update_initial( ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -477,15 +480,14 @@ def _create_or_update_initial( response = pipeline_response.http_response if response.status_code not in [200, 201]: - response.read() # Load the body in memory and close the socket + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 201: - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -510,12 +512,12 @@ def begin_create_or_update( :param vault_name: Name of the vault. Required. :type vault_name: str :param parameters: Parameters to create or update the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.VaultCreateOrUpdateParameters + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.VaultCreateOrUpdateParameters :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_10_01.models.Vault] + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2024_11_01.models.Vault] :raises ~azure.core.exceptions.HttpResponseError: """ @@ -542,7 +544,7 @@ def begin_create_or_update( Default value is "application/json". :paramtype content_type: str :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_10_01.models.Vault] + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2024_11_01.models.Vault] :raises ~azure.core.exceptions.HttpResponseError: """ @@ -563,16 +565,16 @@ def begin_create_or_update( :type vault_name: str :param parameters: Parameters to create or update the vault. Is either a VaultCreateOrUpdateParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.VaultCreateOrUpdateParameters or + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.VaultCreateOrUpdateParameters or IO[bytes] :return: An instance of LROPoller that returns either Vault or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_10_01.models.Vault] + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2024_11_01.models.Vault] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.Vault] = kwargs.pop("cls", None) polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) @@ -634,12 +636,12 @@ def update( :param vault_name: Name of the vault. Required. :type vault_name: str :param parameters: Parameters to patch the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.VaultPatchParameters + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.VaultPatchParameters :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Vault + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Vault :raises ~azure.core.exceptions.HttpResponseError: """ @@ -666,7 +668,7 @@ def update( Default value is "application/json". :paramtype content_type: str :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Vault + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Vault :raises ~azure.core.exceptions.HttpResponseError: """ @@ -687,12 +689,12 @@ def update( :type vault_name: str :param parameters: Parameters to patch the vault. Is either a VaultPatchParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.VaultPatchParameters or IO[bytes] + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.VaultPatchParameters or IO[bytes] :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Vault + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Vault :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -703,7 +705,7 @@ def update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.Vault] = kwargs.pop("cls", None) @@ -739,11 +741,7 @@ def update( map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("Vault", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("Vault", pipeline_response.http_response) + deserialized = self._deserialize("Vault", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -765,7 +763,7 @@ def delete( # pylint: disable=inconsistent-return-statements :rtype: None :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -776,7 +774,7 @@ def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[None] = kwargs.pop("cls", None) _request = build_delete_request( @@ -813,10 +811,10 @@ def get(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> _mode :param vault_name: The name of the vault. Required. :type vault_name: str :return: Vault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Vault + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.Vault :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -827,7 +825,7 @@ def get(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> _mode _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.Vault] = kwargs.pop("cls", None) _request = build_get_request( @@ -878,14 +876,14 @@ def update_access_policy( :type vault_name: str :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2021_10_01.models.AccessPolicyUpdateKind + :type operation_kind: str or ~azure.mgmt.keyvault.v2024_11_01.models.AccessPolicyUpdateKind :param parameters: Access policy to merge into the vault. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.VaultAccessPolicyParameters + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.VaultAccessPolicyParameters :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.VaultAccessPolicyParameters + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.VaultAccessPolicyParameters :raises ~azure.core.exceptions.HttpResponseError: """ @@ -909,14 +907,14 @@ def update_access_policy( :type vault_name: str :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2021_10_01.models.AccessPolicyUpdateKind + :type operation_kind: str or ~azure.mgmt.keyvault.v2024_11_01.models.AccessPolicyUpdateKind :param parameters: Access policy to merge into the vault. Required. :type parameters: IO[bytes] :keyword content_type: Body Parameter content-type. Content type parameter for binary body. Default value is "application/json". :paramtype content_type: str :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.VaultAccessPolicyParameters + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.VaultAccessPolicyParameters :raises ~azure.core.exceptions.HttpResponseError: """ @@ -938,16 +936,16 @@ def update_access_policy( :type vault_name: str :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". Required. - :type operation_kind: str or ~azure.mgmt.keyvault.v2021_10_01.models.AccessPolicyUpdateKind + :type operation_kind: str or ~azure.mgmt.keyvault.v2024_11_01.models.AccessPolicyUpdateKind :param parameters: Access policy to merge into the vault. Is either a VaultAccessPolicyParameters type or a IO[bytes] type. Required. - :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.VaultAccessPolicyParameters or + :type parameters: ~azure.mgmt.keyvault.v2024_11_01.models.VaultAccessPolicyParameters or IO[bytes] :return: VaultAccessPolicyParameters or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.VaultAccessPolicyParameters + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.VaultAccessPolicyParameters :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -958,7 +956,7 @@ def update_access_policy( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.VaultAccessPolicyParameters] = kwargs.pop("cls", None) @@ -995,11 +993,7 @@ def update_access_policy( map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) - - if response.status_code == 201: - deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -1019,16 +1013,16 @@ def list_by_resource_group( :param top: Maximum number of results to return. Default value is None. :type top: int :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.Vault] + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.Vault] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1097,16 +1091,16 @@ def list_by_subscription(self, top: Optional[int] = None, **kwargs: Any) -> Iter :param top: Maximum number of results to return. Default value is None. :type top: int :return: An iterator like instance of either Vault or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.Vault] + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.Vault] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.VaultListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1172,16 +1166,16 @@ def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedVault"]: """Gets information about the deleted vaults in a subscription. :return: An iterator like instance of either DeletedVault or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.DeletedVault] + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.DeletedVault] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.DeletedVaultListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1250,10 +1244,10 @@ def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _models. :param location: The location of the deleted vault. Required. :type location: str :return: DeletedVault or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.DeletedVault + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.DeletedVault :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1264,7 +1258,7 @@ def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _models. _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[_models.DeletedVault] = kwargs.pop("cls", None) _request = build_get_deleted_request( @@ -1296,7 +1290,7 @@ def get_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _models. return deserialized # type: ignore def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1307,7 +1301,7 @@ def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) _request = build_purge_deleted_request( @@ -1320,6 +1314,7 @@ def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) ) _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -1328,15 +1323,14 @@ def _purge_deleted_initial(self, vault_name: str, location: str, **kwargs: Any) response = pipeline_response.http_response if response.status_code not in [200, 202]: - response.read() # Load the body in memory and close the socket + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - - if response.status_code == 202: - deserialized = response.stream_download(self._client._pipeline) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -1358,7 +1352,7 @@ def begin_purge_deleted(self, vault_name: str, location: str, **kwargs: Any) -> _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) cls: ClsType[None] = kwargs.pop("cls", None) polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) @@ -1402,7 +1396,7 @@ def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Re :param top: Maximum number of results to return. Default value is None. :type top: int :return: An iterator like instance of either Resource or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.Resource] + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2024_11_01.models.Resource] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} @@ -1416,7 +1410,7 @@ def list(self, top: Optional[int] = None, **kwargs: Any) -> Iterable["_models.Re ) cls: ClsType[_models.ResourceListResult] = kwargs.pop("cls", None) - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1489,12 +1483,12 @@ def check_name_availability( """Checks that the vault name is valid and is not already in use. :param vault_name: The name of the vault. Required. - :type vault_name: ~azure.mgmt.keyvault.v2021_10_01.models.VaultCheckNameAvailabilityParameters + :type vault_name: ~azure.mgmt.keyvault.v2024_11_01.models.VaultCheckNameAvailabilityParameters :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.CheckNameAvailabilityResult + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.CheckNameAvailabilityResult :raises ~azure.core.exceptions.HttpResponseError: """ @@ -1510,7 +1504,7 @@ def check_name_availability( Default value is "application/json". :paramtype content_type: str :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.CheckNameAvailabilityResult + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.CheckNameAvailabilityResult :raises ~azure.core.exceptions.HttpResponseError: """ @@ -1522,13 +1516,13 @@ def check_name_availability( :param vault_name: The name of the vault. Is either a VaultCheckNameAvailabilityParameters type or a IO[bytes] type. Required. - :type vault_name: ~azure.mgmt.keyvault.v2021_10_01.models.VaultCheckNameAvailabilityParameters + :type vault_name: ~azure.mgmt.keyvault.v2024_11_01.models.VaultCheckNameAvailabilityParameters or IO[bytes] :return: CheckNameAvailabilityResult or the result of cls(response) - :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.CheckNameAvailabilityResult + :rtype: ~azure.mgmt.keyvault.v2024_11_01.models.CheckNameAvailabilityResult :raises ~azure.core.exceptions.HttpResponseError: """ - error_map: MutableMapping[int, Type[HttpResponseError]] = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1539,7 +1533,7 @@ def check_name_availability( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._api_version or "2024-11-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.CheckNameAvailabilityResult] = kwargs.pop("cls", None) diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/py.typed b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/py.typed similarity index 100% rename from sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/py.typed rename to sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2024_11_01/py.typed diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/check_vault_name_availability.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/check_vault_name_availability.py index 73e3fe9046a4..b1b792c1250d 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/check_vault_name_availability.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/check_vault_name_availability.py @@ -6,8 +6,6 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, IO, Union - from azure.identity import DefaultAzureCredential from azure.mgmt.keyvault import KeyVaultManagementClient @@ -38,6 +36,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/checkVaultNameAvailability.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/checkVaultNameAvailability.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/create_key.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/create_key.py index a5f708baa948..b60213cf201f 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/create_key.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/create_key.py @@ -6,8 +6,6 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, IO, Union - from azure.identity import DefaultAzureCredential from azure.mgmt.keyvault import KeyVaultManagementClient @@ -41,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/createKey.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/createKey.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/create_secret.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/create_secret.py index c35cd2777c29..5cc173a0cdb7 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/create_secret.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/create_secret.py @@ -6,8 +6,6 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, IO, Union - from azure.identity import DefaultAzureCredential from azure.mgmt.keyvault import KeyVaultManagementClient @@ -41,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/createSecret.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/createSecret.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/create_vault.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/create_vault.py index 878a935af216..f12953780f72 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/create_vault.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/create_vault.py @@ -6,8 +6,6 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, IO, Union - from azure.identity import DefaultAzureCredential from azure.mgmt.keyvault import KeyVaultManagementClient @@ -93,6 +91,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/createVault.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/createVault.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/create_vault_with_network_acls.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/create_vault_with_network_acls.py index 3d08446a7015..627d77f8c645 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/create_vault_with_network_acls.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/create_vault_with_network_acls.py @@ -6,8 +6,6 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, IO, Union - from azure.identity import DefaultAzureCredential from azure.mgmt.keyvault import KeyVaultManagementClient @@ -59,6 +57,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/createVaultWithNetworkAcls.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/createVaultWithNetworkAcls.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/delete_private_endpoint_connection.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/delete_private_endpoint_connection.py index c3c1f800c25e..f9e65cbb6b35 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/delete_private_endpoint_connection.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/delete_private_endpoint_connection.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/deletePrivateEndpointConnection.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/deletePrivateEndpointConnection.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/delete_vault.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/delete_vault.py index ff5f3be4c5e3..8525c96c3abf 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/delete_vault.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/delete_vault.py @@ -36,6 +36,6 @@ def main(): ) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/deleteVault.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/deleteVault.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/deleted_managed_hsm_get.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/deleted_managed_hsm_get.py index d63a3a90fed2..eb78d8675bdf 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/deleted_managed_hsm_get.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/deleted_managed_hsm_get.py @@ -37,6 +37,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/DeletedManagedHsm_Get.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/DeletedManagedHsm_Get.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/deleted_managed_hsm_list.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/deleted_managed_hsm_list.py index fa561a74c12f..06d822a3b412 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/deleted_managed_hsm_list.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/deleted_managed_hsm_list.py @@ -35,6 +35,6 @@ def main(): print(item) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/DeletedManagedHsm_List.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/DeletedManagedHsm_List.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/deleted_managed_hsm_purge.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/deleted_managed_hsm_purge.py index 8e8185d45abf..0e61f3a6f0ee 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/deleted_managed_hsm_purge.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/deleted_managed_hsm_purge.py @@ -36,6 +36,6 @@ def main(): ).result() -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/DeletedManagedHsm_Purge.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/DeletedManagedHsm_Purge.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_deleted_vault.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_deleted_vault.py index b30aa07af68e..359e51b3bf4f 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_deleted_vault.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_deleted_vault.py @@ -37,6 +37,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/getDeletedVault.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/getDeletedVault.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_key.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_key.py index f63553014207..bb346410ea8d 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_key.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_key.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/getKey.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/getKey.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_key_version.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_key_version.py index 5b1bafb08c0b..09ebe149421c 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_key_version.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_key_version.py @@ -39,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/getKeyVersion.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/getKeyVersion.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_private_endpoint_connection.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_private_endpoint_connection.py index 0f64f6e1e113..d276437771fa 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_private_endpoint_connection.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_private_endpoint_connection.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/getPrivateEndpointConnection.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/getPrivateEndpointConnection.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_secret.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_secret.py index a081d89b7555..e16489bc4d64 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_secret.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_secret.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/getSecret.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/getSecret.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_vault.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_vault.py index f4864e6bca53..c3c2f1e602ea 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_vault.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/get_vault.py @@ -37,6 +37,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/getVault.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/getVault.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_deleted_vaults.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_deleted_vaults.py index bd32923195c0..7654e74000d4 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_deleted_vaults.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_deleted_vaults.py @@ -35,6 +35,6 @@ def main(): print(item) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/listDeletedVaults.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/listDeletedVaults.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_key_versions.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_key_versions.py index 8881035fb5bc..9d48667e56fe 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_key_versions.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_key_versions.py @@ -39,6 +39,6 @@ def main(): print(item) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/listKeyVersions.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/listKeyVersions.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_keys.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_keys.py index ded9e04c9ee9..960d849229f9 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_keys.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_keys.py @@ -38,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/listKeys.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/listKeys.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_operations.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_operations.py index 110208caf799..3735fb8842a6 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_operations.py @@ -35,6 +35,6 @@ def main(): print(item) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/listOperations.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/listOperations.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_private_endpoint_connection.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_private_endpoint_connection.py index eb80d795d7b5..1aa0d8d1b599 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_private_endpoint_connection.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_private_endpoint_connection.py @@ -38,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/listPrivateEndpointConnection.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/listPrivateEndpointConnection.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_private_link_resources.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_private_link_resources.py index 80464f246d26..3176c6d29953 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_private_link_resources.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_private_link_resources.py @@ -37,6 +37,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/listPrivateLinkResources.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/listPrivateLinkResources.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_secrets.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_secrets.py index 8fa7c834349c..ed5446fb8f22 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_secrets.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_secrets.py @@ -38,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/listSecrets.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/listSecrets.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_vault.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_vault.py index c1ab1c2cebbd..cc651ec5dca0 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_vault.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_vault.py @@ -35,6 +35,6 @@ def main(): print(item) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/listVault.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/listVault.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_vault_by_resource_group.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_vault_by_resource_group.py index 3e1bfc6bcd1f..32a074461795 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_vault_by_resource_group.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_vault_by_resource_group.py @@ -37,6 +37,6 @@ def main(): print(item) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/listVaultByResourceGroup.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/listVaultByResourceGroup.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_vault_by_subscription.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_vault_by_subscription.py index 43cf1919b995..00cf62aaa324 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_vault_by_subscription.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/list_vault_by_subscription.py @@ -35,6 +35,6 @@ def main(): print(item) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/listVaultBySubscription.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/listVaultBySubscription.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_check_mhsm_name_availability.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_check_mhsm_name_availability.py index ffa8dc0de2e2..f73c62d88404 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_check_mhsm_name_availability.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_check_mhsm_name_availability.py @@ -6,8 +6,6 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, IO, Union - from azure.identity import DefaultAzureCredential from azure.mgmt.keyvault import KeyVaultManagementClient @@ -38,6 +36,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/ManagedHsm_checkMhsmNameAvailability.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/ManagedHsm_checkMhsmNameAvailability.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_create_key.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_create_key.py index 93b804b7d63a..570c75403184 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_create_key.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_create_key.py @@ -6,8 +6,6 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, IO, Union - from azure.identity import DefaultAzureCredential from azure.mgmt.keyvault import KeyVaultManagementClient @@ -41,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/managedHsmCreateKey.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/managedHsmCreateKey.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_create_or_update.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_create_or_update.py index 3eca084fcf3c..f16343f29e6a 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_create_or_update.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_create_or_update.py @@ -6,8 +6,6 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, IO, Union - from azure.identity import DefaultAzureCredential from azure.mgmt.keyvault import KeyVaultManagementClient @@ -51,6 +49,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/ManagedHsm_CreateOrUpdate.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/ManagedHsm_CreateOrUpdate.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_delete.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_delete.py index 4768f4aaea33..f8ed3c549505 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_delete.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_delete.py @@ -36,6 +36,6 @@ def main(): ).result() -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/ManagedHsm_Delete.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/ManagedHsm_Delete.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_delete_private_endpoint_connection.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_delete_private_endpoint_connection.py index 81b19cba784e..6c9b742ec6c0 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_delete_private_endpoint_connection.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_delete_private_endpoint_connection.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/ManagedHsm_deletePrivateEndpointConnection.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/ManagedHsm_deletePrivateEndpointConnection.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_get.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_get.py index 623714dfabce..418611aa34fa 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_get.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_get.py @@ -37,6 +37,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/ManagedHsm_Get.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/ManagedHsm_Get.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_get_key.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_get_key.py index ab2d1dfe836d..837c52f6e7f9 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_get_key.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_get_key.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/managedHsmGetKey.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/managedHsmGetKey.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_get_key_version.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_get_key_version.py index ce1f5517de8d..4d891e28ee44 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_get_key_version.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_get_key_version.py @@ -39,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/managedHsmGetKeyVersion.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/managedHsmGetKeyVersion.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_get_private_endpoint_connection.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_get_private_endpoint_connection.py index 0e3b9f9ecbfc..63914fcc72ed 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_get_private_endpoint_connection.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_get_private_endpoint_connection.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/ManagedHsm_getPrivateEndpointConnection.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/ManagedHsm_getPrivateEndpointConnection.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_by_resource_group.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_by_resource_group.py index b738728f98d2..439a496e3819 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_by_resource_group.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_by_resource_group.py @@ -37,6 +37,6 @@ def main(): print(item) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/ManagedHsm_ListByResourceGroup.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/ManagedHsm_ListByResourceGroup.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_by_subscription.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_by_subscription.py index 356e4f223de6..b56e9cef6284 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_by_subscription.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_by_subscription.py @@ -35,6 +35,6 @@ def main(): print(item) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/ManagedHsm_ListBySubscription.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/ManagedHsm_ListBySubscription.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_key_versions.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_key_versions.py index 5c4061b745be..f67ab9923657 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_key_versions.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_key_versions.py @@ -39,6 +39,6 @@ def main(): print(item) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/managedHsmListKeyVersions.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/managedHsmListKeyVersions.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_keys.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_keys.py index bde60d72ba4d..20bd5b4636ac 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_keys.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_keys.py @@ -38,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/managedHsmListKeys.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/managedHsmListKeys.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_private_endpoint_connections_by_resource.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_private_endpoint_connections_by_resource.py index 14bacf0f949d..3a866e50131b 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_private_endpoint_connections_by_resource.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_private_endpoint_connections_by_resource.py @@ -38,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/ManagedHsm_ListPrivateEndpointConnectionsByResource.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/ManagedHsm_ListPrivateEndpointConnectionsByResource.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_private_link_resources.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_private_link_resources.py index fb02e13ed678..eda2457436e2 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_private_link_resources.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_private_link_resources.py @@ -37,6 +37,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/ManagedHsm_listPrivateLinkResources.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/ManagedHsm_listPrivateLinkResources.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_regions_by_resource.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_regions_by_resource.py index fe1a349c9a05..03538804e0b5 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_regions_by_resource.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_list_regions_by_resource.py @@ -38,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/ManagedHsm_ListRegionsByResource.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/ManagedHsm_ListRegionsByResource.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_put_private_endpoint_connection.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_put_private_endpoint_connection.py index 2bd33ca45449..fa8b1f320696 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_put_private_endpoint_connection.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_put_private_endpoint_connection.py @@ -6,8 +6,6 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, IO, Union - from azure.identity import DefaultAzureCredential from azure.mgmt.keyvault import KeyVaultManagementClient @@ -48,6 +46,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/ManagedHsm_putPrivateEndpointConnection.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/ManagedHsm_putPrivateEndpointConnection.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_update.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_update.py index 5cd878666142..c9856f65e31e 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_update.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/managed_hsm_update.py @@ -6,8 +6,6 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, IO, Union - from azure.identity import DefaultAzureCredential from azure.mgmt.keyvault import KeyVaultManagementClient @@ -40,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/ManagedHsm_Update.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/ManagedHsm_Update.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/purge_deleted_vault.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/purge_deleted_vault.py index f6888b0be668..0f644186bdfd 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/purge_deleted_vault.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/purge_deleted_vault.py @@ -36,6 +36,6 @@ def main(): ).result() -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/purgeDeletedVault.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/purgeDeletedVault.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/put_private_endpoint_connection.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/put_private_endpoint_connection.py index f0b4b81cfbdc..c55aab2e9679 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/put_private_endpoint_connection.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/put_private_endpoint_connection.py @@ -6,8 +6,6 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, IO, Union - from azure.identity import DefaultAzureCredential from azure.mgmt.keyvault import KeyVaultManagementClient @@ -49,6 +47,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/putPrivateEndpointConnection.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/putPrivateEndpointConnection.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/update_access_policies_add.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/update_access_policies_add.py index a93563149aad..655ac7930f61 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/update_access_policies_add.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/update_access_policies_add.py @@ -6,15 +6,10 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, IO, TYPE_CHECKING, Union - from azure.identity import DefaultAzureCredential from azure.mgmt.keyvault import KeyVaultManagementClient -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from .. import models as _models """ # PREREQUISITES pip install azure-identity @@ -54,6 +49,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/updateAccessPoliciesAdd.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/updateAccessPoliciesAdd.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/update_secret.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/update_secret.py index 7ea4eec33d89..b602c25f8c04 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/update_secret.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/update_secret.py @@ -6,8 +6,6 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, IO, Union - from azure.identity import DefaultAzureCredential from azure.mgmt.keyvault import KeyVaultManagementClient @@ -41,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/updateSecret.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/updateSecret.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/update_vault.py b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/update_vault.py index ed5c070aa322..8c7965043431 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_samples/update_vault.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_samples/update_vault.py @@ -6,8 +6,6 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, IO, Union - from azure.identity import DefaultAzureCredential from azure.mgmt.keyvault import KeyVaultManagementClient @@ -92,6 +90,6 @@ def main(): print(response) -# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2023-07-01/examples/updateVault.json +# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/updateVault.json if __name__ == "__main__": main() diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/conftest.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/conftest.py index 2f33a97f09c7..924599a32089 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/conftest.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/conftest.py @@ -18,7 +18,7 @@ load_dotenv() -# aovid record sensitive identity information in recordings +# For security, please avoid record sensitive identity information in recordings @pytest.fixture(scope="session", autouse=True) def add_sanitizers(test_proxy): keyvaultmanagement_subscription_id = os.environ.get("AZURE_SUBSCRIPTION_ID", "00000000-0000-0000-0000-000000000000") diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_keys_operations.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_keys_operations.py index 83bbe9b58423..f10dcefb2131 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_keys_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_keys_operations.py @@ -20,7 +20,7 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_create_if_not_exist(self, resource_group): + def test_keys_create_if_not_exist(self, resource_group): response = self.client.keys.create_if_not_exist( resource_group_name=resource_group.name, vault_name="str", @@ -58,7 +58,7 @@ def test_create_if_not_exist(self, resource_group): }, "tags": {"str": "str"}, }, - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -66,12 +66,12 @@ def test_create_if_not_exist(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_get(self, resource_group): + def test_keys_get(self, resource_group): response = self.client.keys.get( resource_group_name=resource_group.name, vault_name="str", key_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -79,11 +79,11 @@ def test_get(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_list(self, resource_group): + def test_keys_list(self, resource_group): response = self.client.keys.list( resource_group_name=resource_group.name, vault_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r for r in response] # please add some check logic here by yourself @@ -91,13 +91,13 @@ def test_list(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_get_version(self, resource_group): + def test_keys_get_version(self, resource_group): response = self.client.keys.get_version( resource_group_name=resource_group.name, vault_name="str", key_name="str", key_version="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -105,12 +105,12 @@ def test_get_version(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_list_versions(self, resource_group): + def test_keys_list_versions(self, resource_group): response = self.client.keys.list_versions( resource_group_name=resource_group.name, vault_name="str", key_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r for r in response] # please add some check logic here by yourself diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_keys_operations_async.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_keys_operations_async.py index 816fea325878..c514d5213207 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_keys_operations_async.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_keys_operations_async.py @@ -21,7 +21,7 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_create_if_not_exist(self, resource_group): + async def test_keys_create_if_not_exist(self, resource_group): response = await self.client.keys.create_if_not_exist( resource_group_name=resource_group.name, vault_name="str", @@ -59,7 +59,7 @@ async def test_create_if_not_exist(self, resource_group): }, "tags": {"str": "str"}, }, - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -67,12 +67,12 @@ async def test_create_if_not_exist(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_get(self, resource_group): + async def test_keys_get(self, resource_group): response = await self.client.keys.get( resource_group_name=resource_group.name, vault_name="str", key_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -80,11 +80,11 @@ async def test_get(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_list(self, resource_group): + async def test_keys_list(self, resource_group): response = self.client.keys.list( resource_group_name=resource_group.name, vault_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r async for r in response] # please add some check logic here by yourself @@ -92,13 +92,13 @@ async def test_list(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_get_version(self, resource_group): + async def test_keys_get_version(self, resource_group): response = await self.client.keys.get_version( resource_group_name=resource_group.name, vault_name="str", key_name="str", key_version="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -106,12 +106,12 @@ async def test_get_version(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_list_versions(self, resource_group): + async def test_keys_list_versions(self, resource_group): response = self.client.keys.list_versions( resource_group_name=resource_group.name, vault_name="str", key_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r async for r in response] # please add some check logic here by yourself diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_managed_hsm_keys_operations.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_managed_hsm_keys_operations.py index 458942c37200..eb722955fd06 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_managed_hsm_keys_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_managed_hsm_keys_operations.py @@ -20,7 +20,7 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_create_if_not_exist(self, resource_group): + def test_managed_hsm_keys_create_if_not_exist(self, resource_group): response = self.client.managed_hsm_keys.create_if_not_exist( resource_group_name=resource_group.name, name="str", @@ -58,7 +58,7 @@ def test_create_if_not_exist(self, resource_group): }, "tags": {"str": "str"}, }, - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -66,12 +66,12 @@ def test_create_if_not_exist(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_get(self, resource_group): + def test_managed_hsm_keys_get(self, resource_group): response = self.client.managed_hsm_keys.get( resource_group_name=resource_group.name, name="str", key_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -79,11 +79,11 @@ def test_get(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_list(self, resource_group): + def test_managed_hsm_keys_list(self, resource_group): response = self.client.managed_hsm_keys.list( resource_group_name=resource_group.name, name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r for r in response] # please add some check logic here by yourself @@ -91,13 +91,13 @@ def test_list(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_get_version(self, resource_group): + def test_managed_hsm_keys_get_version(self, resource_group): response = self.client.managed_hsm_keys.get_version( resource_group_name=resource_group.name, name="str", key_name="str", key_version="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -105,12 +105,12 @@ def test_get_version(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_list_versions(self, resource_group): + def test_managed_hsm_keys_list_versions(self, resource_group): response = self.client.managed_hsm_keys.list_versions( resource_group_name=resource_group.name, name="str", key_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r for r in response] # please add some check logic here by yourself diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_managed_hsm_keys_operations_async.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_managed_hsm_keys_operations_async.py index b09c8b48ddbc..e801f4304cc3 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_managed_hsm_keys_operations_async.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_managed_hsm_keys_operations_async.py @@ -21,7 +21,7 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_create_if_not_exist(self, resource_group): + async def test_managed_hsm_keys_create_if_not_exist(self, resource_group): response = await self.client.managed_hsm_keys.create_if_not_exist( resource_group_name=resource_group.name, name="str", @@ -59,7 +59,7 @@ async def test_create_if_not_exist(self, resource_group): }, "tags": {"str": "str"}, }, - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -67,12 +67,12 @@ async def test_create_if_not_exist(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_get(self, resource_group): + async def test_managed_hsm_keys_get(self, resource_group): response = await self.client.managed_hsm_keys.get( resource_group_name=resource_group.name, name="str", key_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -80,11 +80,11 @@ async def test_get(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_list(self, resource_group): + async def test_managed_hsm_keys_list(self, resource_group): response = self.client.managed_hsm_keys.list( resource_group_name=resource_group.name, name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r async for r in response] # please add some check logic here by yourself @@ -92,13 +92,13 @@ async def test_list(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_get_version(self, resource_group): + async def test_managed_hsm_keys_get_version(self, resource_group): response = await self.client.managed_hsm_keys.get_version( resource_group_name=resource_group.name, name="str", key_name="str", key_version="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -106,12 +106,12 @@ async def test_get_version(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_list_versions(self, resource_group): + async def test_managed_hsm_keys_list_versions(self, resource_group): response = self.client.managed_hsm_keys.list_versions( resource_group_name=resource_group.name, name="str", key_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r async for r in response] # please add some check logic here by yourself diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_managed_hsms_operations.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_managed_hsms_operations.py index 8a3d11234efb..dd4f6e5b8f1f 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_managed_hsms_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_managed_hsms_operations.py @@ -20,7 +20,7 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_begin_create_or_update(self, resource_group): + def test_managed_hsms_begin_create_or_update(self, resource_group): response = self.client.managed_hsms.begin_create_or_update( resource_group_name=resource_group.name, name="str", @@ -80,7 +80,7 @@ def test_begin_create_or_update(self, resource_group): "tags": {"str": "str"}, "type": "str", }, - api_version="2023-07-01", + api_version="2024-11-01", ).result() # call '.result()' to poll until service return final result # please add some check logic here by yourself @@ -88,7 +88,7 @@ def test_begin_create_or_update(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_begin_update(self, resource_group): + def test_managed_hsms_begin_update(self, resource_group): response = self.client.managed_hsms.begin_update( resource_group_name=resource_group.name, name="str", @@ -148,7 +148,7 @@ def test_begin_update(self, resource_group): "tags": {"str": "str"}, "type": "str", }, - api_version="2023-07-01", + api_version="2024-11-01", ).result() # call '.result()' to poll until service return final result # please add some check logic here by yourself @@ -156,11 +156,11 @@ def test_begin_update(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_begin_delete(self, resource_group): + def test_managed_hsms_begin_delete(self, resource_group): response = self.client.managed_hsms.begin_delete( resource_group_name=resource_group.name, name="str", - api_version="2023-07-01", + api_version="2024-11-01", ).result() # call '.result()' to poll until service return final result # please add some check logic here by yourself @@ -168,11 +168,11 @@ def test_begin_delete(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_get(self, resource_group): + def test_managed_hsms_get(self, resource_group): response = self.client.managed_hsms.get( resource_group_name=resource_group.name, name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -180,10 +180,10 @@ def test_get(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_list_by_resource_group(self, resource_group): + def test_managed_hsms_list_by_resource_group(self, resource_group): response = self.client.managed_hsms.list_by_resource_group( resource_group_name=resource_group.name, - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r for r in response] # please add some check logic here by yourself @@ -191,9 +191,9 @@ def test_list_by_resource_group(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_list_by_subscription(self, resource_group): + def test_managed_hsms_list_by_subscription(self, resource_group): response = self.client.managed_hsms.list_by_subscription( - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r for r in response] # please add some check logic here by yourself @@ -201,9 +201,9 @@ def test_list_by_subscription(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_list_deleted(self, resource_group): + def test_managed_hsms_list_deleted(self, resource_group): response = self.client.managed_hsms.list_deleted( - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r for r in response] # please add some check logic here by yourself @@ -211,11 +211,11 @@ def test_list_deleted(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_get_deleted(self, resource_group): + def test_managed_hsms_get_deleted(self, resource_group): response = self.client.managed_hsms.get_deleted( name="str", location="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -223,11 +223,11 @@ def test_get_deleted(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_begin_purge_deleted(self, resource_group): + def test_managed_hsms_begin_purge_deleted(self, resource_group): response = self.client.managed_hsms.begin_purge_deleted( name="str", location="str", - api_version="2023-07-01", + api_version="2024-11-01", ).result() # call '.result()' to poll until service return final result # please add some check logic here by yourself @@ -235,10 +235,10 @@ def test_begin_purge_deleted(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_check_mhsm_name_availability(self, resource_group): + def test_managed_hsms_check_mhsm_name_availability(self, resource_group): response = self.client.managed_hsms.check_mhsm_name_availability( mhsm_name={"name": "str"}, - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_managed_hsms_operations_async.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_managed_hsms_operations_async.py index 63231a0daa1d..879d5536a1ab 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_managed_hsms_operations_async.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_managed_hsms_operations_async.py @@ -21,7 +21,7 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_begin_create_or_update(self, resource_group): + async def test_managed_hsms_begin_create_or_update(self, resource_group): response = await ( await self.client.managed_hsms.begin_create_or_update( resource_group_name=resource_group.name, @@ -82,7 +82,7 @@ async def test_begin_create_or_update(self, resource_group): "tags": {"str": "str"}, "type": "str", }, - api_version="2023-07-01", + api_version="2024-11-01", ) ).result() # call '.result()' to poll until service return final result @@ -91,7 +91,7 @@ async def test_begin_create_or_update(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_begin_update(self, resource_group): + async def test_managed_hsms_begin_update(self, resource_group): response = await ( await self.client.managed_hsms.begin_update( resource_group_name=resource_group.name, @@ -152,7 +152,7 @@ async def test_begin_update(self, resource_group): "tags": {"str": "str"}, "type": "str", }, - api_version="2023-07-01", + api_version="2024-11-01", ) ).result() # call '.result()' to poll until service return final result @@ -161,12 +161,12 @@ async def test_begin_update(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_begin_delete(self, resource_group): + async def test_managed_hsms_begin_delete(self, resource_group): response = await ( await self.client.managed_hsms.begin_delete( resource_group_name=resource_group.name, name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) ).result() # call '.result()' to poll until service return final result @@ -175,11 +175,11 @@ async def test_begin_delete(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_get(self, resource_group): + async def test_managed_hsms_get(self, resource_group): response = await self.client.managed_hsms.get( resource_group_name=resource_group.name, name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -187,10 +187,10 @@ async def test_get(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_list_by_resource_group(self, resource_group): + async def test_managed_hsms_list_by_resource_group(self, resource_group): response = self.client.managed_hsms.list_by_resource_group( resource_group_name=resource_group.name, - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r async for r in response] # please add some check logic here by yourself @@ -198,9 +198,9 @@ async def test_list_by_resource_group(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_list_by_subscription(self, resource_group): + async def test_managed_hsms_list_by_subscription(self, resource_group): response = self.client.managed_hsms.list_by_subscription( - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r async for r in response] # please add some check logic here by yourself @@ -208,9 +208,9 @@ async def test_list_by_subscription(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_list_deleted(self, resource_group): + async def test_managed_hsms_list_deleted(self, resource_group): response = self.client.managed_hsms.list_deleted( - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r async for r in response] # please add some check logic here by yourself @@ -218,11 +218,11 @@ async def test_list_deleted(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_get_deleted(self, resource_group): + async def test_managed_hsms_get_deleted(self, resource_group): response = await self.client.managed_hsms.get_deleted( name="str", location="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -230,12 +230,12 @@ async def test_get_deleted(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_begin_purge_deleted(self, resource_group): + async def test_managed_hsms_begin_purge_deleted(self, resource_group): response = await ( await self.client.managed_hsms.begin_purge_deleted( name="str", location="str", - api_version="2023-07-01", + api_version="2024-11-01", ) ).result() # call '.result()' to poll until service return final result @@ -244,10 +244,10 @@ async def test_begin_purge_deleted(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_check_mhsm_name_availability(self, resource_group): + async def test_managed_hsms_check_mhsm_name_availability(self, resource_group): response = await self.client.managed_hsms.check_mhsm_name_availability( mhsm_name={"name": "str"}, - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_private_endpoint_connections_operations.py index 2be6db7e3003..244a5834301b 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_private_endpoint_connections_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_private_endpoint_connections_operations.py @@ -20,11 +20,11 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_list_by_resource(self, resource_group): + def test_mhsm_private_endpoint_connections_list_by_resource(self, resource_group): response = self.client.mhsm_private_endpoint_connections.list_by_resource( resource_group_name=resource_group.name, name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r for r in response] # please add some check logic here by yourself @@ -32,12 +32,12 @@ def test_list_by_resource(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_get(self, resource_group): + def test_mhsm_private_endpoint_connections_get(self, resource_group): response = self.client.mhsm_private_endpoint_connections.get( resource_group_name=resource_group.name, name="str", private_endpoint_connection_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -45,7 +45,7 @@ def test_get(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_put(self, resource_group): + def test_mhsm_private_endpoint_connections_put(self, resource_group): response = self.client.mhsm_private_endpoint_connections.put( resource_group_name=resource_group.name, name="str", @@ -76,7 +76,7 @@ def test_put(self, resource_group): "tags": {"str": "str"}, "type": "str", }, - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -84,12 +84,12 @@ def test_put(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_begin_delete(self, resource_group): + def test_mhsm_private_endpoint_connections_begin_delete(self, resource_group): response = self.client.mhsm_private_endpoint_connections.begin_delete( resource_group_name=resource_group.name, name="str", private_endpoint_connection_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ).result() # call '.result()' to poll until service return final result # please add some check logic here by yourself diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_private_endpoint_connections_operations_async.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_private_endpoint_connections_operations_async.py index 61fd22575a5d..b3bf407483d5 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_private_endpoint_connections_operations_async.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_private_endpoint_connections_operations_async.py @@ -21,11 +21,11 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_list_by_resource(self, resource_group): + async def test_mhsm_private_endpoint_connections_list_by_resource(self, resource_group): response = self.client.mhsm_private_endpoint_connections.list_by_resource( resource_group_name=resource_group.name, name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r async for r in response] # please add some check logic here by yourself @@ -33,12 +33,12 @@ async def test_list_by_resource(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_get(self, resource_group): + async def test_mhsm_private_endpoint_connections_get(self, resource_group): response = await self.client.mhsm_private_endpoint_connections.get( resource_group_name=resource_group.name, name="str", private_endpoint_connection_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -46,7 +46,7 @@ async def test_get(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_put(self, resource_group): + async def test_mhsm_private_endpoint_connections_put(self, resource_group): response = await self.client.mhsm_private_endpoint_connections.put( resource_group_name=resource_group.name, name="str", @@ -77,7 +77,7 @@ async def test_put(self, resource_group): "tags": {"str": "str"}, "type": "str", }, - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -85,13 +85,13 @@ async def test_put(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_begin_delete(self, resource_group): + async def test_mhsm_private_endpoint_connections_begin_delete(self, resource_group): response = await ( await self.client.mhsm_private_endpoint_connections.begin_delete( resource_group_name=resource_group.name, name="str", private_endpoint_connection_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) ).result() # call '.result()' to poll until service return final result diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_private_link_resources_operations.py index a34a8e97ba8e..ceb58f5a6e99 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_private_link_resources_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_private_link_resources_operations.py @@ -20,11 +20,11 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_list_by_mhsm_resource(self, resource_group): + def test_mhsm_private_link_resources_list_by_mhsm_resource(self, resource_group): response = self.client.mhsm_private_link_resources.list_by_mhsm_resource( resource_group_name=resource_group.name, name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_private_link_resources_operations_async.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_private_link_resources_operations_async.py index 423129d78eb2..70d5287d38f9 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_private_link_resources_operations_async.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_private_link_resources_operations_async.py @@ -21,11 +21,11 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_list_by_mhsm_resource(self, resource_group): + async def test_mhsm_private_link_resources_list_by_mhsm_resource(self, resource_group): response = await self.client.mhsm_private_link_resources.list_by_mhsm_resource( resource_group_name=resource_group.name, name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_regions_operations.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_regions_operations.py index b84d378a2eb0..26b0cb04f96b 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_regions_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_regions_operations.py @@ -20,11 +20,11 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_list_by_resource(self, resource_group): + def test_mhsm_regions_list_by_resource(self, resource_group): response = self.client.mhsm_regions.list_by_resource( resource_group_name=resource_group.name, name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r for r in response] # please add some check logic here by yourself diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_regions_operations_async.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_regions_operations_async.py index e0c286563e23..9c0b844ffd23 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_regions_operations_async.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_mhsm_regions_operations_async.py @@ -21,11 +21,11 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_list_by_resource(self, resource_group): + async def test_mhsm_regions_list_by_resource(self, resource_group): response = self.client.mhsm_regions.list_by_resource( resource_group_name=resource_group.name, name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r async for r in response] # please add some check logic here by yourself diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_operations.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_operations.py index 6b904c83df29..49b33066fd42 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_operations.py @@ -20,9 +20,9 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_list(self, resource_group): + def test_operations_list(self, resource_group): response = self.client.operations.list( - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r for r in response] # please add some check logic here by yourself diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_operations_async.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_operations_async.py index cc8d37178d66..1746dc6d9d21 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_operations_async.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_operations_async.py @@ -21,9 +21,9 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_list(self, resource_group): + async def test_operations_list(self, resource_group): response = self.client.operations.list( - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r async for r in response] # please add some check logic here by yourself diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_private_endpoint_connections_operations.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_private_endpoint_connections_operations.py index f97783b3757e..468fc4b3b508 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_private_endpoint_connections_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_private_endpoint_connections_operations.py @@ -20,12 +20,12 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_get(self, resource_group): + def test_private_endpoint_connections_get(self, resource_group): response = self.client.private_endpoint_connections.get( resource_group_name=resource_group.name, vault_name="str", private_endpoint_connection_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -33,7 +33,7 @@ def test_get(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_put(self, resource_group): + def test_private_endpoint_connections_put(self, resource_group): response = self.client.private_endpoint_connections.put( resource_group_name=resource_group.name, vault_name="str", @@ -49,7 +49,7 @@ def test_put(self, resource_group): "tags": {"str": "str"}, "type": "str", }, - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -57,12 +57,12 @@ def test_put(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_begin_delete(self, resource_group): + def test_private_endpoint_connections_begin_delete(self, resource_group): response = self.client.private_endpoint_connections.begin_delete( resource_group_name=resource_group.name, vault_name="str", private_endpoint_connection_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ).result() # call '.result()' to poll until service return final result # please add some check logic here by yourself @@ -70,11 +70,11 @@ def test_begin_delete(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_list_by_resource(self, resource_group): + def test_private_endpoint_connections_list_by_resource(self, resource_group): response = self.client.private_endpoint_connections.list_by_resource( resource_group_name=resource_group.name, vault_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r for r in response] # please add some check logic here by yourself diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_private_endpoint_connections_operations_async.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_private_endpoint_connections_operations_async.py index a7e8fd14fc17..ab3540e9a914 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_private_endpoint_connections_operations_async.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_private_endpoint_connections_operations_async.py @@ -21,12 +21,12 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_get(self, resource_group): + async def test_private_endpoint_connections_get(self, resource_group): response = await self.client.private_endpoint_connections.get( resource_group_name=resource_group.name, vault_name="str", private_endpoint_connection_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -34,7 +34,7 @@ async def test_get(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_put(self, resource_group): + async def test_private_endpoint_connections_put(self, resource_group): response = await self.client.private_endpoint_connections.put( resource_group_name=resource_group.name, vault_name="str", @@ -50,7 +50,7 @@ async def test_put(self, resource_group): "tags": {"str": "str"}, "type": "str", }, - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -58,13 +58,13 @@ async def test_put(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_begin_delete(self, resource_group): + async def test_private_endpoint_connections_begin_delete(self, resource_group): response = await ( await self.client.private_endpoint_connections.begin_delete( resource_group_name=resource_group.name, vault_name="str", private_endpoint_connection_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) ).result() # call '.result()' to poll until service return final result @@ -73,11 +73,11 @@ async def test_begin_delete(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_list_by_resource(self, resource_group): + async def test_private_endpoint_connections_list_by_resource(self, resource_group): response = self.client.private_endpoint_connections.list_by_resource( resource_group_name=resource_group.name, vault_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r async for r in response] # please add some check logic here by yourself diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_private_link_resources_operations.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_private_link_resources_operations.py index 0c8d9fe10db6..2b084a1c482e 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_private_link_resources_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_private_link_resources_operations.py @@ -20,11 +20,11 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_list_by_vault(self, resource_group): + def test_private_link_resources_list_by_vault(self, resource_group): response = self.client.private_link_resources.list_by_vault( resource_group_name=resource_group.name, vault_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_private_link_resources_operations_async.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_private_link_resources_operations_async.py index ef50a781beda..8256009e6cb3 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_private_link_resources_operations_async.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_private_link_resources_operations_async.py @@ -21,11 +21,11 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_list_by_vault(self, resource_group): + async def test_private_link_resources_list_by_vault(self, resource_group): response = await self.client.private_link_resources.list_by_vault( resource_group_name=resource_group.name, vault_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_secrets_operations.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_secrets_operations.py index d080bb956b8a..acc2a552da75 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_secrets_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_secrets_operations.py @@ -20,7 +20,7 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_create_or_update(self, resource_group): + def test_secrets_create_or_update(self, resource_group): response = self.client.secrets.create_or_update( resource_group_name=resource_group.name, vault_name="str", @@ -41,7 +41,7 @@ def test_create_or_update(self, resource_group): }, "tags": {"str": "str"}, }, - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -49,7 +49,7 @@ def test_create_or_update(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_update(self, resource_group): + def test_secrets_update(self, resource_group): response = self.client.secrets.update( resource_group_name=resource_group.name, vault_name="str", @@ -68,7 +68,7 @@ def test_update(self, resource_group): }, "tags": {"str": "str"}, }, - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -76,12 +76,12 @@ def test_update(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_get(self, resource_group): + def test_secrets_get(self, resource_group): response = self.client.secrets.get( resource_group_name=resource_group.name, vault_name="str", secret_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -89,11 +89,11 @@ def test_get(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_list(self, resource_group): + def test_secrets_list(self, resource_group): response = self.client.secrets.list( resource_group_name=resource_group.name, vault_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r for r in response] # please add some check logic here by yourself diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_secrets_operations_async.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_secrets_operations_async.py index ad48b8930a22..ae80c479bf2d 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_secrets_operations_async.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_secrets_operations_async.py @@ -21,7 +21,7 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_create_or_update(self, resource_group): + async def test_secrets_create_or_update(self, resource_group): response = await self.client.secrets.create_or_update( resource_group_name=resource_group.name, vault_name="str", @@ -42,7 +42,7 @@ async def test_create_or_update(self, resource_group): }, "tags": {"str": "str"}, }, - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -50,7 +50,7 @@ async def test_create_or_update(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_update(self, resource_group): + async def test_secrets_update(self, resource_group): response = await self.client.secrets.update( resource_group_name=resource_group.name, vault_name="str", @@ -69,7 +69,7 @@ async def test_update(self, resource_group): }, "tags": {"str": "str"}, }, - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -77,12 +77,12 @@ async def test_update(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_get(self, resource_group): + async def test_secrets_get(self, resource_group): response = await self.client.secrets.get( resource_group_name=resource_group.name, vault_name="str", secret_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -90,11 +90,11 @@ async def test_get(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_list(self, resource_group): + async def test_secrets_list(self, resource_group): response = self.client.secrets.list( resource_group_name=resource_group.name, vault_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r async for r in response] # please add some check logic here by yourself diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_vaults_operations.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_vaults_operations.py index eb8d7f66ca33..590aa966982e 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_vaults_operations.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_vaults_operations.py @@ -20,7 +20,7 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_begin_create_or_update(self, resource_group): + def test_vaults_begin_create_or_update(self, resource_group): response = self.client.vaults.begin_create_or_update( resource_group_name=resource_group.name, vault_name="str", @@ -46,9 +46,9 @@ def test_begin_create_or_update(self, resource_group): "enablePurgeProtection": bool, "enableRbacAuthorization": False, "enableSoftDelete": True, - "enabledForDeployment": bool, - "enabledForDiskEncryption": bool, - "enabledForTemplateDeployment": bool, + "enabledForDeployment": False, + "enabledForDiskEncryption": False, + "enabledForTemplateDeployment": False, "hsmPoolResourceId": "str", "networkAcls": { "bypass": "str", @@ -76,7 +76,7 @@ def test_begin_create_or_update(self, resource_group): }, "tags": {"str": "str"}, }, - api_version="2023-07-01", + api_version="2024-11-01", ).result() # call '.result()' to poll until service return final result # please add some check logic here by yourself @@ -84,7 +84,7 @@ def test_begin_create_or_update(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_update(self, resource_group): + def test_vaults_update(self, resource_group): response = self.client.vaults.update( resource_group_name=resource_group.name, vault_name="str", @@ -123,7 +123,7 @@ def test_update(self, resource_group): }, "tags": {"str": "str"}, }, - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -131,11 +131,11 @@ def test_update(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_delete(self, resource_group): + def test_vaults_delete(self, resource_group): response = self.client.vaults.delete( resource_group_name=resource_group.name, vault_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -143,11 +143,11 @@ def test_delete(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_get(self, resource_group): + def test_vaults_get(self, resource_group): response = self.client.vaults.get( resource_group_name=resource_group.name, vault_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -155,7 +155,7 @@ def test_get(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_update_access_policy(self, resource_group): + def test_vaults_update_access_policy(self, resource_group): response = self.client.vaults.update_access_policy( resource_group_name=resource_group.name, vault_name="str", @@ -181,7 +181,7 @@ def test_update_access_policy(self, resource_group): "name": "str", "type": "str", }, - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -189,10 +189,10 @@ def test_update_access_policy(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_list_by_resource_group(self, resource_group): + def test_vaults_list_by_resource_group(self, resource_group): response = self.client.vaults.list_by_resource_group( resource_group_name=resource_group.name, - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r for r in response] # please add some check logic here by yourself @@ -200,9 +200,9 @@ def test_list_by_resource_group(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_list_by_subscription(self, resource_group): + def test_vaults_list_by_subscription(self, resource_group): response = self.client.vaults.list_by_subscription( - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r for r in response] # please add some check logic here by yourself @@ -210,9 +210,9 @@ def test_list_by_subscription(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_list_deleted(self, resource_group): + def test_vaults_list_deleted(self, resource_group): response = self.client.vaults.list_deleted( - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r for r in response] # please add some check logic here by yourself @@ -220,11 +220,11 @@ def test_list_deleted(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_get_deleted(self, resource_group): + def test_vaults_get_deleted(self, resource_group): response = self.client.vaults.get_deleted( vault_name="str", location="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -232,11 +232,11 @@ def test_get_deleted(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_begin_purge_deleted(self, resource_group): + def test_vaults_begin_purge_deleted(self, resource_group): response = self.client.vaults.begin_purge_deleted( vault_name="str", location="str", - api_version="2023-07-01", + api_version="2024-11-01", ).result() # call '.result()' to poll until service return final result # please add some check logic here by yourself @@ -244,7 +244,7 @@ def test_begin_purge_deleted(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_list(self, resource_group): + def test_vaults_list(self, resource_group): response = self.client.vaults.list( filter="resourceType eq 'Microsoft.KeyVault/vaults'", api_version="2015-11-01", @@ -255,10 +255,10 @@ def test_list(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_check_name_availability(self, resource_group): + def test_vaults_check_name_availability(self, resource_group): response = self.client.vaults.check_name_availability( vault_name={"name": "str", "type": "Microsoft.KeyVault/vaults"}, - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself diff --git a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_vaults_operations_async.py b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_vaults_operations_async.py index 6ff927fa974b..813730d5e623 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_vaults_operations_async.py +++ b/sdk/keyvault/azure-mgmt-keyvault/generated_tests/test_key_vault_management_vaults_operations_async.py @@ -21,7 +21,7 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_begin_create_or_update(self, resource_group): + async def test_vaults_begin_create_or_update(self, resource_group): response = await ( await self.client.vaults.begin_create_or_update( resource_group_name=resource_group.name, @@ -48,9 +48,9 @@ async def test_begin_create_or_update(self, resource_group): "enablePurgeProtection": bool, "enableRbacAuthorization": False, "enableSoftDelete": True, - "enabledForDeployment": bool, - "enabledForDiskEncryption": bool, - "enabledForTemplateDeployment": bool, + "enabledForDeployment": False, + "enabledForDiskEncryption": False, + "enabledForTemplateDeployment": False, "hsmPoolResourceId": "str", "networkAcls": { "bypass": "str", @@ -78,7 +78,7 @@ async def test_begin_create_or_update(self, resource_group): }, "tags": {"str": "str"}, }, - api_version="2023-07-01", + api_version="2024-11-01", ) ).result() # call '.result()' to poll until service return final result @@ -87,7 +87,7 @@ async def test_begin_create_or_update(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_update(self, resource_group): + async def test_vaults_update(self, resource_group): response = await self.client.vaults.update( resource_group_name=resource_group.name, vault_name="str", @@ -126,7 +126,7 @@ async def test_update(self, resource_group): }, "tags": {"str": "str"}, }, - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -134,11 +134,11 @@ async def test_update(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_delete(self, resource_group): + async def test_vaults_delete(self, resource_group): response = await self.client.vaults.delete( resource_group_name=resource_group.name, vault_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -146,11 +146,11 @@ async def test_delete(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_get(self, resource_group): + async def test_vaults_get(self, resource_group): response = await self.client.vaults.get( resource_group_name=resource_group.name, vault_name="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -158,7 +158,7 @@ async def test_get(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_update_access_policy(self, resource_group): + async def test_vaults_update_access_policy(self, resource_group): response = await self.client.vaults.update_access_policy( resource_group_name=resource_group.name, vault_name="str", @@ -184,7 +184,7 @@ async def test_update_access_policy(self, resource_group): "name": "str", "type": "str", }, - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -192,10 +192,10 @@ async def test_update_access_policy(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_list_by_resource_group(self, resource_group): + async def test_vaults_list_by_resource_group(self, resource_group): response = self.client.vaults.list_by_resource_group( resource_group_name=resource_group.name, - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r async for r in response] # please add some check logic here by yourself @@ -203,9 +203,9 @@ async def test_list_by_resource_group(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_list_by_subscription(self, resource_group): + async def test_vaults_list_by_subscription(self, resource_group): response = self.client.vaults.list_by_subscription( - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r async for r in response] # please add some check logic here by yourself @@ -213,9 +213,9 @@ async def test_list_by_subscription(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_list_deleted(self, resource_group): + async def test_vaults_list_deleted(self, resource_group): response = self.client.vaults.list_deleted( - api_version="2023-07-01", + api_version="2024-11-01", ) result = [r async for r in response] # please add some check logic here by yourself @@ -223,11 +223,11 @@ async def test_list_deleted(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_get_deleted(self, resource_group): + async def test_vaults_get_deleted(self, resource_group): response = await self.client.vaults.get_deleted( vault_name="str", location="str", - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself @@ -235,12 +235,12 @@ async def test_get_deleted(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_begin_purge_deleted(self, resource_group): + async def test_vaults_begin_purge_deleted(self, resource_group): response = await ( await self.client.vaults.begin_purge_deleted( vault_name="str", location="str", - api_version="2023-07-01", + api_version="2024-11-01", ) ).result() # call '.result()' to poll until service return final result @@ -249,7 +249,7 @@ async def test_begin_purge_deleted(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_list(self, resource_group): + async def test_vaults_list(self, resource_group): response = self.client.vaults.list( filter="resourceType eq 'Microsoft.KeyVault/vaults'", api_version="2015-11-01", @@ -260,10 +260,10 @@ async def test_list(self, resource_group): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_check_name_availability(self, resource_group): + async def test_vaults_check_name_availability(self, resource_group): response = await self.client.vaults.check_name_availability( vault_name={"name": "str", "type": "Microsoft.KeyVault/vaults"}, - api_version="2023-07-01", + api_version="2024-11-01", ) # please add some check logic here by yourself